#define LIBVA_UTILS_UPLOAD_DOWNLOAD_YUV_SURFACE 1 #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "va_display.h" #define ALIGN16(x) ((x+15)&~15) #define CHECK_VASTATUS(va_status,func) \ if (va_status != VA_STATUS_SUCCESS) { \ fprintf(stderr,"%s:%s (%d) failed,exit\n", __func__, func, __LINE__); \ exit(1); \ } #define MIN(a, b) ((a)>(b)?(b):(a)) #define MAX(a, b) ((a)>(b)?(a):(b)) #define CHECK_NULL(p) \ if(!(p)) \ { \ fprintf(stderr, "Null pointer at:%s:%d\n", __func__, __LINE__); \ exit(1); \ } #define CHECK_CONDITION(cond) \ if(!(cond)) \ { \ fprintf(stderr, "Unexpected condition: %s:%d\n", __func__, __LINE__); \ exit(1); \ } #define CHECK_BS_NULL(p) \ CHECK_NULL(p) \ CHECK_NULL(p->buffer) #include "loadsurface.h" /***** * * Bit stream management * * * */ #define BITSTREAM_ALLOCATE_STEPPING 1024 // in byte struct __bitstream { uint8_t *buffer; // managed by u8 to avoid swap every 4byte int bit_offset; int max_size_in_byte; }; typedef struct __bitstream bitstream; static void bitstream_start(bitstream *bs) { CHECK_NULL(bs); bs->max_size_in_byte = BITSTREAM_ALLOCATE_STEPPING; bs->buffer = calloc(bs->max_size_in_byte * sizeof(uint8_t), 1); CHECK_NULL(bs->buffer); bs->bit_offset = 0; } static void put_ui(bitstream* bs, uint32_t val, int size_in_bits) { CHECK_BS_NULL(bs); CHECK_CONDITION((size_in_bits + bs->bit_offset) <= (8 * bs->max_size_in_byte)); int remain_bits = 8 - (bs->bit_offset % 8); // make sure val does not overflow size_in_bits val &= (0xffffffff >> (32 - size_in_bits)); if(size_in_bits <= remain_bits) { bs->buffer[bs->bit_offset / 8] |= val << (remain_bits - size_in_bits); bs->bit_offset += size_in_bits; } else { put_ui(bs, val >> (size_in_bits - remain_bits), remain_bits); put_ui(bs, val & (~(0xffffffff << (size_in_bits - remain_bits))), size_in_bits - remain_bits); } } static void put_aligning_bits(bitstream* bs) { CHECK_BS_NULL(bs); while (bs->bit_offset & 7) put_ui(bs, 0, 1);; //trailing_zero_bit } static void put_trailing_bits(bitstream* bs) { CHECK_BS_NULL(bs); put_ui(bs, 1, 1); //trailing_one_bit while (bs->bit_offset & 7) put_ui(bs, 0, 1);; //trailing_zero_bit } static void bitstream_free(bitstream* bs) { CHECK_BS_NULL(bs); free(bs->buffer); bs->bit_offset = 0; bs->max_size_in_byte = 0; } static void bitstream_cat(bitstream *bs1, bitstream *bs2) { CHECK_NULL(bs1); CHECK_NULL(bs2); CHECK_CONDITION(! (bs1->bit_offset & 7)); if(! (bs1->bit_offset & 7)) //byte aligned { memcpy(bs1->buffer + (bs1->bit_offset / 8), bs2->buffer, bs2->bit_offset/8); bs1->bit_offset += bs2->bit_offset; bitstream_free(bs2); } else { //when call this function to concat 2 bitstreams, the first bitstream should always be byte aligned CHECK_CONDITION(0); } } /****** * definition of para set structure * * * * */ #define PRIMARY_REF_BITS 3 #define PRIMARY_REF_NONE 7 #define REF_FRAMES_LOG2 3 #define NUM_REF_FRAMES (1 << REF_FRAMES_LOG2) #define REFS_PER_FRAME 7 #define TOTAL_REFS_PER_FRAME 8 #define MAX_MODE_LF_DELTAS 2 #define MAX_MB_PLANE 3 #define CDEF_MAX_STRENGTHS 8 #define CDEF_STRENGTH_BITS 6 #define CDEF_STRENGTH_DIVISOR 4 #define AV1_MAX_NUM_TILE_COLS 64 #define AV1_MAX_NUM_TILE_ROWS 64 #define MAX_NUM_OPERATING_POINTS 32 #define SURFACE_NUM 16 /* 16 surfaces for source YUV */ enum { SINGLE_REFERENCE = 0, COMPOUND_REFERENCE = 1, REFERENCE_MODE_SELECT = 2, REFERENCE_MODES = 3, } REFERENCE_MODE; enum FRAME_TYPE { KEY_FRAME = 0, INTER_FRAME = 1, INTRA_ONLY_FRAME = 2, SWITCH_FRAME = 3, NUM_FRAME_TYPES, }; enum INTERP_FILTER{ EIGHTTAP_REGULAR, EIGHTTAP_SMOOTH, EIGHTTAP_SHARP, BILINEAR, SWITCHABLE, INTERP_FILTERS_ALL }; enum AV1_OBU_TYPE { OBU_SEQUENCE_HEADER = 1, OBU_TEMPORAL_DELIMITER = 2, OBU_FRAME_HEADER = 3, OBU_TILE_GROUP = 4, OBU_METADATA = 5, OBU_FRAME = 6, OBU_REDUNDANT_FRAME_HEADER = 7, OBU_PADDING = 15, }; struct LoopFilterParams { int32_t loop_filter_level[4]; int32_t loop_filter_sharpness; uint8_t loop_filter_delta_enabled; uint8_t loop_filter_delta_update; // 0 = Intra, Last, Last2, Last3, GF, BWD, ARF int8_t loop_filter_ref_deltas[TOTAL_REFS_PER_FRAME]; // 0 = ZERO_MV, MV int8_t loop_filter_mode_deltas[MAX_MODE_LF_DELTAS]; }; struct TileInfoAv1 { uint32_t uniform_tile_spacing_flag; uint32_t TileColsLog2; uint32_t TileRowsLog2; uint32_t TileCols; uint32_t TileRows; uint32_t TileWidthInSB[AV1_MAX_NUM_TILE_COLS]; // valid for 0 <= i < TileCols uint32_t TileHeightInSB[AV1_MAX_NUM_TILE_ROWS]; // valid for 0 <= i < TileRows uint32_t context_update_tile_id; uint32_t TileSizeBytes; }; struct QuantizationParams { uint32_t base_q_idx; int32_t DeltaQYDc; int32_t DeltaQUDc; int32_t DeltaQUAc; int32_t DeltaQVDc; int32_t DeltaQVAc; uint32_t using_qmatrix; uint32_t qm_y; uint32_t qm_u; uint32_t qm_v; }; struct CdefParams { uint32_t cdef_damping; uint32_t cdef_bits; uint32_t cdef_y_pri_strength[CDEF_MAX_STRENGTHS]; uint32_t cdef_y_sec_strength[CDEF_MAX_STRENGTHS]; uint32_t cdef_uv_pri_strength[CDEF_MAX_STRENGTHS]; uint32_t cdef_uv_sec_strength[CDEF_MAX_STRENGTHS]; }; enum RestorationType { RESTORE_NONE, RESTORE_SWITCHABLE, RESTORE_WIENER, RESTORE_SGRPROJ, RESTORE_TYPES = 4, }; enum { BITDEPTH_8 = 8, BITDEPTH_10 = 10 }; enum { INTRA_FRAME = 0, LAST_FRAME = 1, LAST2_FRAME = 2, LAST3_FRAME = 3, GOLDEN_FRAME = 4, BWDREF_FRAME = 5, ALTREF2_FRAME = 6, ALTREF_FRAME = 7, MAX_REF_FRAMES = 8 }; struct LRParams { enum RestorationType lr_type[MAX_MB_PLANE]; uint32_t lr_unit_shift; uint32_t lr_uv_shift; uint32_t lr_unit_extra_shift; }; enum TX_MODE{ ONLY_4X4 = 0, // only 4x4 transform used TX_MODE_LARGEST, // transform size is the largest possible for pu size TX_MODE_SELECT, // transform specified for each block TX_MODES, }; struct ColorConfig { uint32_t BitDepth ; uint32_t mono_chrome ; uint32_t color_primaries ; uint32_t transfer_characteristics ; uint32_t matrix_coefficients ; uint32_t color_description_present_flag; uint32_t color_range ; uint32_t chroma_sample_position ; uint32_t subsampling_x ; uint32_t subsampling_y ; uint32_t separate_uv_delta_q ; }; typedef struct FrameHeader { uint32_t show_existing_frame; uint32_t frame_to_show_map_idx; uint64_t frame_presentation_time; uint32_t display_frame_id; enum FRAME_TYPE frame_type; uint32_t show_frame; uint32_t showable_frame; uint32_t error_resilient_mode; uint32_t disable_cdf_update; uint32_t allow_screen_content_tools; uint32_t force_integer_mv; uint32_t frame_size_override_flag; uint32_t order_hint; uint32_t primary_ref_frame; uint8_t refresh_frame_flags; uint32_t FrameWidth;//input uint32_t FrameHeight;//input uint32_t use_superres; uint32_t SuperresDenom; uint32_t UpscaledWidth; uint32_t RenderWidth; uint32_t RenderHeight; uint32_t allow_intrabc; int32_t ref_frame_idx[REFS_PER_FRAME]; uint32_t allow_high_precision_mv; enum INTERP_FILTER interpolation_filter; //uint32_t is_motion_mode_switchable; uint32_t use_ref_frame_mvs; uint32_t disable_frame_end_update_cdf; uint32_t sbCols; uint32_t sbRows; uint32_t sbSize; //64 by default struct TileInfoAv1 tile_info; struct QuantizationParams quantization_params; uint32_t delta_q_present; uint32_t delta_q_res; uint32_t delta_lf_present; uint32_t delta_lf_res; uint32_t delta_lf_multi; uint32_t CodedLossless; uint32_t AllLossless; struct LoopFilterParams loop_filter_params; struct CdefParams cdef_params; struct LRParams lr_params; enum TX_MODE TxMode; uint32_t reference_select; uint32_t skipModeAllowed; uint32_t skipModeFrame[2]; uint32_t skip_mode_present; uint32_t allow_warped_motion; uint32_t reduced_tx_set; } FH; typedef struct SequenceHeader { uint32_t seq_profile ; uint32_t still_picture ; uint32_t reduced_still_picture_header ; uint32_t timing_info_present_flag ; uint32_t decoder_model_info_present_flag ; uint32_t operating_points_cnt_minus_1 ; uint32_t operating_point_idc[MAX_NUM_OPERATING_POINTS] ; uint32_t seq_level_idx[MAX_NUM_OPERATING_POINTS] ; uint32_t seq_tier[MAX_NUM_OPERATING_POINTS] ; uint32_t decoder_model_present_for_this_op[MAX_NUM_OPERATING_POINTS] ; uint32_t initial_display_delay_minus_1[MAX_NUM_OPERATING_POINTS] ; uint32_t frame_width_bits ; //15 as default value uint32_t frame_height_bits ; //15 as default value uint32_t frame_id_numbers_present_flag ; // default 0 uint32_t sbSize ; //default 64 uint32_t enable_filter_intra ; uint32_t enable_intra_edge_filter ; uint32_t enable_interintra_compound ; uint32_t enable_masked_compound ; uint32_t enable_warped_motion ; uint32_t enable_dual_filter ; uint32_t enable_order_hint ;//default set to 1 uint32_t enable_jnt_comp ; uint32_t enable_ref_frame_mvs ; uint32_t seq_force_screen_content_tools ; uint32_t seq_force_integer_mv ; uint32_t order_hint_bits_minus1 ; //default 8 - 1 uint32_t enable_superres ; uint32_t enable_cdef ; uint32_t enable_restoration ; struct ColorConfig color_config; //default uint32_t film_grain_param_present ; uint32_t frame_rate_extN; uint32_t frame_rate_extD; } SH; struct ObuExtensionHeader { uint32_t temporal_id; uint32_t spatial_id; }; struct BitOffsets { uint32_t QIndexBitOffset; uint32_t SegmentationBitOffset; uint32_t SegmentationBitSize; uint32_t LoopFilterParamsBitOffset; uint32_t FrameHdrOBUSizeInBits; uint32_t FrameHdrOBUSizeByteOffset; uint32_t UncompressedHeaderByteOffset; uint32_t CDEFParamsBitOffset; uint32_t CDEFParamsSizeInBits; }; struct Av1InputParameters { char* srcyuv; char* recyuv; char* output; uint32_t profile; uint32_t order_hint_bits; uint32_t enable_cdef; uint32_t width; uint32_t height; uint32_t LDB; uint32_t frame_rate_extN; uint32_t frame_rate_extD; uint32_t level; // for brc uint32_t bit_rate; uint8_t MinBaseQIndex; uint8_t MaxBaseQIndex; uint32_t intra_period; uint32_t ip_period; uint32_t RateControlMethod; uint32_t BRefType; int encode_syncmode; int calc_psnr; int frame_count; int frame_width_aligned; int frame_height_aligned; uint32_t base_qindex; int bit_depth; int target_bitrate; int vbr_max_bitrate; int buffer_size; int initial_buffer_fullness; }; static VADisplay va_dpy; static VAProfile av1_profile; static VAEntrypoint entryPoint; static VAConfigAttrib attrib[VAConfigAttribTypeMax]; static VAConfigAttrib config_attrib[VAConfigAttribTypeMax]; static int config_attrib_num = 0; static VASurfaceID src_surface[SURFACE_NUM]; static VABufferID coded_buf[SURFACE_NUM]; static VASurfaceID ref_surface[SURFACE_NUM]; static VAConfigID config_id; static VAContextID context_id; // buffer static VAEncSequenceParameterBufferAV1 seq_param; static VAEncPictureParameterBufferAV1 pic_param; static VAEncTileGroupBufferAV1 tile_group_param; // sh fh ips static struct Av1InputParameters ips; static FH fh; static SH sh; struct BitOffsets offsets; //Default entrypoint for Encode static VAEntrypoint requested_entrypoint = -1; static unsigned long long current_frame_encoding = 0; static unsigned long long current_frame_display = 0; static int current_frame_type; #define current_slot (current_frame_display % SURFACE_NUM) /* thread to save coded data/upload source YUV */ struct storage_task_t { void *next; unsigned long long display_order; unsigned long long encode_order; }; static struct storage_task_t *storage_task_header = NULL, *storage_task_tail = NULL; #define SRC_SURFACE_IN_ENCODING 0 #define SRC_SURFACE_IN_STORAGE 1 static int srcsurface_status[SURFACE_NUM]; //static int encode_syncmode = 0; moved to input pars static pthread_mutex_t encode_mutex = PTHREAD_MUTEX_INITIALIZER; static pthread_cond_t encode_cond = PTHREAD_COND_INITIALIZER; static pthread_t encode_thread; static FILE *coded_fp = NULL, *srcyuv_fp = NULL, *recyuv_fp = NULL; static unsigned long long srcyuv_frames = 0; static int srcyuv_fourcc = VA_FOURCC_IYUV; static uint64_t frame_size = 0; /* for performance profiling */ static unsigned int UploadPictureTicks = 0; static unsigned int BeginPictureTicks = 0; static unsigned int RenderPictureTicks = 0; static unsigned int EndPictureTicks = 0; static unsigned int SyncPictureTicks = 0; static unsigned int SavePictureTicks = 0; static unsigned int TotalTicks = 0; static unsigned int frame_coded = 0; static int rc_default_modes[] = { VA_RC_VBR, VA_RC_CQP, VA_RC_VBR_CONSTRAINED, VA_RC_CBR, VA_RC_VCM, VA_RC_NONE, }; static int len_ivf_header; static int len_seq_header; static int len_pic_header; /* * Helper function for profiling purposes */ static unsigned int GetTickCount() { struct timeval tv; if (gettimeofday(&tv, NULL)) return 0; return tv.tv_usec / 1000 + tv.tv_sec * 1000; } static int string_to_fourcc(char *str) { CHECK_NULL(str); int fourcc; if (!strncmp(str, "NV12", 4)) fourcc = VA_FOURCC_NV12; else if (!strncmp(str, "IYUV", 4)) fourcc = VA_FOURCC_IYUV; else if (!strncmp(str, "YV12", 4)) fourcc = VA_FOURCC_YV12; else if (!strncmp(str, "UYVY", 4)) fourcc = VA_FOURCC_UYVY; else { printf("Unknow FOURCC\n"); fourcc = -1; } return fourcc; } static int string_to_rc(char *str) { CHECK_NULL(str); int rc_mode; if (!strncmp(str, "NONE", 4)) rc_mode = VA_RC_NONE; else if (!strncmp(str, "CBR", 3)) rc_mode = VA_RC_CBR; else if (!strncmp(str, "VBR", 3)) rc_mode = VA_RC_VBR; else if (!strncmp(str, "VCM", 3)) rc_mode = VA_RC_VCM; else if (!strncmp(str, "CQP", 3)) rc_mode = VA_RC_CQP; else if (!strncmp(str, "VBR_CONSTRAINED", 15)) rc_mode = VA_RC_VBR_CONSTRAINED; else { printf("Unknown RC mode\n"); rc_mode = -1; } return rc_mode; } static void print_help() { printf("./av1encode \n"); printf(" -n -f -o \n"); printf(" --intra_period \n"); printf(" --ip_period \n"); printf(" --rcmode <16 for CQP>\n"); printf(" --srcyuv load YUV from a file\n"); printf(" --fourcc source YUV fourcc\n"); printf(" --recyuv save reconstructed YUV into a file\n"); printf(" --enablePSNR calculate PSNR of recyuv vs. srcyuv\n"); printf(" --level\n"); printf(" --height \n"); printf(" --width \n"); printf(" --base_q_idx 1-255\n"); printf(" --normal_mode select VAEntrypointEncSlice as entrypoint\n"); printf(" --low_power_mode select VAEntrypointEncSliceLP as entrypoint\n"); printf(" sample usage:\n"); printf("./av1encode -n 8 -f 30 --intra_period 4 --ip_period 1 --rcmode CQP --srcyuv ./input.yuv --recyuv ./rec.yuv --fourcc IYUV --level 8 --width 1920 --height 1080 --base_q_idx 128 -o ./out.av1 --LDB --low_power_mode\n" "./av1encode -n 8 -f 30 --intra_period 4 --ip_period 1 --rcmode CBR --srcyuv ./input.yuv --recyuv ./rec.yuv --fourcc IYUV --level 8 --width 1920 --height 1080 --target_bitrate 3360000 -o ./out.av1 --LDB --low_power_mode\n" "./av1encode -n 8 -f 30 --intra_period 4 --ip_period 1 --rcmode VBR --srcyuv ./input.yuv --recyuv ./rec.yuv --fourcc IYUV --level 8 --width 1920 --height 1080 --vbr_max_bitrate 3360000 -o ./out.av1 --LDB --low_power_mode\n"); } static void process_cmdline(int argc, char *argv[]) { int c; const struct option long_opts[] = { {"help", no_argument, NULL, 0 }, {"intra_period", required_argument, NULL, 1 }, {"ip_period", required_argument, NULL, 2 }, {"rcmode", required_argument, NULL, 3 }, {"srcyuv", required_argument, NULL, 4 }, {"recyuv", required_argument, NULL, 5 }, {"fourcc", required_argument, NULL, 6 }, {"syncmode", no_argument, NULL, 7 }, {"enablePSNR", no_argument, NULL, 8 }, {"level", required_argument, NULL, 9 }, {"height", required_argument, NULL, 10 }, {"width", required_argument, NULL, 11 }, {"base_q_idx", required_argument, NULL, 12}, {"LDB", no_argument, NULL, 13}, {"normal_mode", no_argument, NULL, 14}, {"low_power_mode", no_argument, NULL, 15}, {"target_bitrate", required_argument, NULL, 16}, {"vbr_max_bitrate", required_argument, NULL, 17}, {NULL, no_argument, NULL, 0 } }; int long_index; while ((c = getopt_long_only(argc, argv, "n:f:o:t:m:u:d:?", long_opts, &long_index)) != EOF) { switch (c) { case 'n': ips.frame_count = atoi(optarg); break; case 'f': ips.frame_rate_extN = (int)(atoi(optarg) * 100); ips.frame_rate_extD = 100; break; case 'o': ips.output = strdup(optarg); break; case 1: ips.intra_period = atoi(optarg); break; case 2: ips.ip_period = atoi(optarg); break; case 3: ips.RateControlMethod = string_to_rc(optarg); //16:cqp 2:CBR 4:VBR break; case 4: ips.srcyuv = strdup(optarg); break; case 5: ips.recyuv = strdup(optarg); break; case 6: srcyuv_fourcc = string_to_fourcc(optarg); break; case 7: ips.encode_syncmode = 1; break; case 8: ips.calc_psnr = 1; break; case 9: ips.level = atoi(optarg); break; case 10: ips.height = atoi(optarg); ips.frame_height_aligned = (ips.height + 63) & (~63); break; case 11: ips.width = atoi(optarg); ips.frame_width_aligned = (ips.width + 63) & (~63); break; case 12: ips.base_qindex = atoi(optarg); break; case 13: ips.LDB = 1; break; case 14: requested_entrypoint = VAEntrypointEncSlice; break; case 15: requested_entrypoint = VAEntrypointEncSliceLP; break; case 't': case 16: ips.target_bitrate = atoi(optarg); break; case 'm': case 17: ips.vbr_max_bitrate = atoi(optarg); break; case 'u': ips.buffer_size = atoi(optarg) * 8000; break; case 'd': ips.initial_buffer_fullness = atoi(optarg) * 8000; break; case 0: case ':': case '?': print_help(); exit(0); } } // init other input parameters as default value ips.MaxBaseQIndex = 255; ips.MinBaseQIndex = 1; ips.bit_depth = 8; if (ips.frame_rate_extD == 0) { ips.frame_rate_extN = 3000; ips.frame_rate_extD = 100; } int default_bitrate = (long long int) ips.height * ips.width * 12 * ips.frame_rate_extN / ips.frame_rate_extD / 50; // For CBR, target bitrate should be set if(ips.RateControlMethod == VA_RC_CBR) { if (ips.target_bitrate == 0) { ips.target_bitrate = default_bitrate; } } // For VBR, max bitrate should be set else if (ips.RateControlMethod == VA_RC_VBR) { if (ips.target_bitrate == 0 && ips.vbr_max_bitrate == 0) { ips.vbr_max_bitrate = default_bitrate; } else if (ips.vbr_max_bitrate == 0) { ips.vbr_max_bitrate = ips.target_bitrate; } } // interface with IO /* open source file */ if (ips.srcyuv) { srcyuv_fp = fopen(ips.srcyuv, "r"); if (srcyuv_fp == NULL) printf("Open source YUV file %s failed, use auto-generated YUV data\n", ips.srcyuv); else { struct stat tmp; int ret = fstat(fileno(srcyuv_fp), &tmp); CHECK_CONDITION(ret == 0); srcyuv_frames = tmp.st_size / (ips.width * ips.height * 1.5); printf("Source YUV file %s with %llu frames\n", ips.srcyuv, srcyuv_frames); if (ips.frame_count == 0) ips.frame_count = srcyuv_frames; } } /* open source file */ if (ips.recyuv) { recyuv_fp = fopen(ips.recyuv, "w+"); if (recyuv_fp == NULL) printf("Open reconstructed YUV file %s failed\n", ips.recyuv); } if (ips.output == NULL) { struct stat buf; if (stat("/tmp", &buf) == 0) ips.output = strdup("/tmp/test.av1"); else if (stat("/sdcard", &buf) == 0) ips.output = strdup("/sdcard/test.av1"); else ips.output = strdup("./test.av1"); } /* store coded data into a file */ if (ips.output) { coded_fp = fopen(ips.output, "w+"); } else { printf("Copy file string failed"); exit(1); } if (coded_fp == NULL) { printf("Open file %s failed, exit\n", ips.output); exit(1); } } static char *rc_to_string(int rcmode) { switch (rcmode) { case VA_RC_NONE: return "NONE"; case VA_RC_CBR: return "CBR"; case VA_RC_VBR: return "VBR"; case VA_RC_VCM: return "VCM"; case VA_RC_CQP: return "CQP"; case VA_RC_VBR_CONSTRAINED: return "VBR_CONSTRAINED"; default: return "Unknown"; } } static int print_input() { printf("frame count: %d \n", ips.frame_count); printf("frame rate: %d \n", ips.frame_rate_extN / ips.frame_rate_extD); printf("Intra period: %d \n", ips.intra_period); printf("Gop ref dist: %d \n", ips.ip_period); printf("rcmode: %s \n", rc_to_string(ips.RateControlMethod)); printf("source yuv: %s \n", ips.srcyuv); printf("recon yuv: %s \n", ips.recyuv); printf("output bitstream: %s \n", ips.output); printf("level index: %d \n", ips.level); printf("frame height: %d \n", ips.height); printf("frame width: %d \n", ips.width); printf("base_q_index: %d \n", ips.base_qindex); printf("target_bitrate: %d bps\n", ips.target_bitrate); printf("vbr_max_bitrate: %d bps\n", ips.vbr_max_bitrate); return 0; } static int init_va(void) { va_dpy = va_open_display(); VAStatus va_status; int major_ver, minor_ver; va_status = vaInitialize(va_dpy, &major_ver, &minor_ver); CHECK_VASTATUS(va_status, "vaInitialize"); av1_profile = VAProfileAV1Profile0; // select entrypoint int num_entrypoints = vaMaxNumEntrypoints(va_dpy); VAEntrypoint* entrypoints = malloc(num_entrypoints * sizeof(*entrypoints)); if (!entrypoints) { fprintf(stderr, "error: failed to initialize VA entrypoints array\n"); exit(1); } vaQueryConfigEntrypoints(va_dpy, av1_profile, entrypoints, &num_entrypoints); int support_encode = 0; for (int slice_entrypoint = 0; slice_entrypoint < num_entrypoints; slice_entrypoint++) { if (requested_entrypoint == -1) { //Select the entry point based on what is avaiable if ((entrypoints[slice_entrypoint] == VAEntrypointEncSlice) || (entrypoints[slice_entrypoint] == VAEntrypointEncSliceLP)) { support_encode = 1; entryPoint = entrypoints[slice_entrypoint]; break; } } else if ((entrypoints[slice_entrypoint] == requested_entrypoint)) { //Select the entry point based on what was requested in cmd line option support_encode = 1; entryPoint = entrypoints[slice_entrypoint]; break; } } if(entrypoints) free(entrypoints); if (support_encode == 0) { printf("Can't find avaiable or requested entrypoints for AV1 profiles\n"); exit(1); } unsigned int i; for (i = 0; i < VAConfigAttribTypeMax; i++) attrib[i].type = i; va_status = vaGetConfigAttributes(va_dpy, av1_profile, entryPoint, &attrib[0], VAConfigAttribTypeMax); CHECK_VASTATUS(va_status, "vaGetConfigAttributes"); /* check the interested configattrib */ if ((attrib[VAConfigAttribRTFormat].value & VA_RT_FORMAT_YUV420) == 0) { printf("Not find desired YUV420 RT format\n"); exit(1); } else { config_attrib[config_attrib_num].type = VAConfigAttribRTFormat; config_attrib[config_attrib_num].value = VA_RT_FORMAT_YUV420; config_attrib_num++; } if (attrib[VAConfigAttribRateControl].value != VA_ATTRIB_NOT_SUPPORTED) { int tmp = attrib[VAConfigAttribRateControl].value; printf("Support rate control mode (0x%x):", tmp); if (tmp & VA_RC_NONE) printf("NONE "); if (tmp & VA_RC_CBR) printf("CBR "); if (tmp & VA_RC_VBR) printf("VBR "); if (tmp & VA_RC_VCM) printf("VCM "); if (tmp & VA_RC_CQP) printf("CQP "); if (tmp & VA_RC_VBR_CONSTRAINED) printf("VBR_CONSTRAINED "); printf("\n"); if (ips.RateControlMethod == -1 || !(ips.RateControlMethod & tmp)) { if (ips.RateControlMethod != -1) { printf("Warning: Don't support the specified RateControl mode: %s!!!, switch to ", rc_to_string(ips.RateControlMethod)); } for (i = 0; i < sizeof(rc_default_modes) / sizeof(rc_default_modes[0]); i++) { if (rc_default_modes[i] & tmp) { ips.RateControlMethod = rc_default_modes[i]; break; } } printf("RateControl mode: %s\n", rc_to_string(ips.RateControlMethod)); } config_attrib[config_attrib_num].type = VAConfigAttribRateControl; config_attrib[config_attrib_num].value = ips.RateControlMethod; config_attrib_num++; } if (attrib[VAConfigAttribEncPackedHeaders].value != VA_ATTRIB_NOT_SUPPORTED) { int tmp = attrib[VAConfigAttribEncPackedHeaders].value; printf("Support VAConfigAttribEncPackedHeaders\n"); config_attrib[config_attrib_num].type = VAConfigAttribEncPackedHeaders; config_attrib[config_attrib_num].value = VA_ENC_PACKED_HEADER_NONE; if (tmp & VA_ENC_PACKED_HEADER_SEQUENCE) { printf("Support packed sequence headers\n"); config_attrib[config_attrib_num].value |= VA_ENC_PACKED_HEADER_SEQUENCE; } if (tmp & VA_ENC_PACKED_HEADER_PICTURE) { printf("Support packed picture headers\n"); config_attrib[config_attrib_num].value |= VA_ENC_PACKED_HEADER_PICTURE; } if (tmp & VA_ENC_PACKED_HEADER_SLICE) { printf("Support packed slice headers\n"); config_attrib[config_attrib_num].value |= VA_ENC_PACKED_HEADER_SLICE; } if (tmp & VA_ENC_PACKED_HEADER_MISC) { printf("Support packed misc headers\n"); config_attrib[config_attrib_num].value |= VA_ENC_PACKED_HEADER_MISC; } config_attrib_num++; } if (attrib[VAConfigAttribEncInterlaced].value != VA_ATTRIB_NOT_SUPPORTED) { int tmp = attrib[VAConfigAttribEncInterlaced].value; printf("Support VAConfigAttribEncInterlaced\n"); if (tmp & VA_ENC_INTERLACED_FRAME) printf("support VA_ENC_INTERLACED_FRAME\n"); if (tmp & VA_ENC_INTERLACED_FIELD) printf("Support VA_ENC_INTERLACED_FIELD\n"); if (tmp & VA_ENC_INTERLACED_MBAFF) printf("Support VA_ENC_INTERLACED_MBAFF\n"); if (tmp & VA_ENC_INTERLACED_PAFF) printf("Support VA_ENC_INTERLACED_PAFF\n"); config_attrib[config_attrib_num].type = VAConfigAttribEncInterlaced; config_attrib[config_attrib_num].value = VA_ENC_PACKED_HEADER_NONE; config_attrib_num++; } return 0; } static int setup_encode() { VAStatus va_status; VASurfaceID *tmp_surfaceid; int codedbuf_size, i; va_status = vaCreateConfig(va_dpy, av1_profile, entryPoint, &config_attrib[0], config_attrib_num, &config_id); CHECK_VASTATUS(va_status, "vaCreateConfig"); /* create source surfaces */ va_status = vaCreateSurfaces(va_dpy, VA_RT_FORMAT_YUV420, ips.frame_width_aligned, ips.frame_height_aligned, &src_surface[0], SURFACE_NUM, NULL, 0); CHECK_VASTATUS(va_status, "vaCreateSurfaces"); /* create reference surfaces */ va_status = vaCreateSurfaces( va_dpy, VA_RT_FORMAT_YUV420, ips.frame_width_aligned, ips.frame_height_aligned, &ref_surface[0], SURFACE_NUM, NULL, 0 ); CHECK_VASTATUS(va_status, "vaCreateSurfaces"); tmp_surfaceid = calloc(2 * SURFACE_NUM, sizeof(VASurfaceID)); if (tmp_surfaceid) { memcpy(tmp_surfaceid, src_surface, SURFACE_NUM * sizeof(VASurfaceID)); memcpy(tmp_surfaceid + SURFACE_NUM, ref_surface, SURFACE_NUM * sizeof(VASurfaceID)); } /* Create a context for this encode pipe */ va_status = vaCreateContext(va_dpy, config_id, ips.frame_width_aligned, ips.frame_height_aligned, VA_PROGRESSIVE, tmp_surfaceid, 2 * SURFACE_NUM, &context_id); CHECK_VASTATUS(va_status, "vaCreateContext"); free(tmp_surfaceid); codedbuf_size = ((long long int) ips.frame_width_aligned * ips.frame_height_aligned * 400) / (16 * 16); for (i = 0; i < SURFACE_NUM; i++) { /* create coded buffer once for all * other VA buffers which won't be used again after vaRenderPicture. * so APP can always vaCreateBuffer for every frame * but coded buffer need to be mapped and accessed after vaRenderPicture/vaEndPicture * so VA won't maintain the coded buffer */ va_status = vaCreateBuffer(va_dpy, context_id, VAEncCodedBufferType, codedbuf_size, 1, NULL, &coded_buf[i]); CHECK_VASTATUS(va_status, "vaCreateBuffer"); } return 0; } static int release_encode() { int i; vaDestroySurfaces(va_dpy, &src_surface[0], SURFACE_NUM); vaDestroySurfaces(va_dpy, &ref_surface[0], SURFACE_NUM); for (i = 0; i < SURFACE_NUM; i++) vaDestroyBuffer(va_dpy, coded_buf[i]); vaDestroyContext(va_dpy, context_id); vaDestroyConfig(va_dpy, config_id); return 0; } static int deinit_va() { vaTerminate(va_dpy); va_close_display(va_dpy); return 0; } /* * Return displaying order with specified periods and encoding order * displaying_order: displaying order * frame_type: frame type */ void encoding2display_order( unsigned long long encoding_order, int intra_period, unsigned long long *displaying_order, int *frame_type) { // simple case for IPPP av1 *displaying_order = encoding_order; // all KEY FRAME *frame_type = KEY_FRAME; *frame_type = (encoding_order % intra_period) ? INTER_FRAME : KEY_FRAME; return; } static void fill_sps_header() { memset(&sh, 0, sizeof(sh)); sh.seq_level_idx[0] = ips.level; sh.frame_width_bits = 15; sh.frame_height_bits = 15; sh.sbSize = 64; sh.order_hint_bits_minus1 = 8 - 1; sh.enable_cdef = 1; sh.enable_order_hint = 1; sh.color_config.separate_uv_delta_q = 1; } static void fill_pps_header(uint64_t displaying_order) { fh.show_existing_frame = 0; fh.frame_to_show_map_idx = 0; fh.frame_presentation_time = 0; fh.display_frame_id = 0; fh.frame_type = current_frame_type; fh.show_frame = 1; fh.showable_frame = 1; fh.error_resilient_mode = (fh.frame_type == KEY_FRAME) ? 1 : 0; fh.disable_cdf_update = 0; fh.allow_screen_content_tools = 0; fh.force_integer_mv = 0; fh.frame_size_override_flag = 0; fh.order_hint = displaying_order; //for I/P frame fh.primary_ref_frame = (fh.frame_type == KEY_FRAME || fh.frame_type == INTRA_ONLY_FRAME) ? PRIMARY_REF_NONE : 0; // depends on reference frames // by default, always refresh idx0 fh.refresh_frame_flags = (fh.frame_type == KEY_FRAME || fh.frame_type == INTRA_ONLY_FRAME) ? 0xff : 0x01; fh.FrameWidth = ips.width; fh.FrameHeight = ips.height; fh.use_superres = 0; fh.SuperresDenom = 0; fh.UpscaledWidth = fh.FrameWidth; fh.RenderWidth = fh.FrameWidth; fh.RenderHeight = fh.FrameHeight; fh.allow_intrabc = 0; for(uint8_t i = 0; i < REFS_PER_FRAME; i++) fh.ref_frame_idx[i] = 0; fh.allow_high_precision_mv = 0; fh.interpolation_filter = 0; fh.use_ref_frame_mvs = 0; fh.disable_frame_end_update_cdf = 0; fh.sbCols = ((fh.FrameWidth+63)&(~63))/64; fh.sbRows = ((fh.FrameHeight+63)&(~63))/64; fh.sbSize = 64; fh.tile_info.uniform_tile_spacing_flag = 1; fh.tile_info.context_update_tile_id = 0; fh.quantization_params.base_q_idx = ips.base_qindex; fh.quantization_params.DeltaQYDc = 0; fh.quantization_params.DeltaQUDc = 0; fh.quantization_params.DeltaQUAc = 0; fh.quantization_params.DeltaQVDc = 0; fh.quantization_params.DeltaQVAc = 0; fh.quantization_params.using_qmatrix = 0; fh.quantization_params.qm_y = 15; fh.quantization_params.qm_u = 15; fh.quantization_params.qm_v = 15; fh.delta_q_present = 0; fh.delta_q_res = 0; fh.delta_lf_present = 1; fh.delta_lf_res = 0; fh.delta_lf_multi = 1; fh.CodedLossless = 0; fh.AllLossless = 0; fh.cdef_params.cdef_damping = 5; fh.cdef_params.cdef_bits = 3; fh.cdef_params.cdef_y_pri_strength[0] = 9; fh.cdef_params.cdef_y_sec_strength[0] = 0; fh.cdef_params.cdef_uv_pri_strength[0] = 9; fh.cdef_params.cdef_uv_sec_strength[0] = 0; fh.cdef_params.cdef_y_pri_strength[1] = 12; fh.cdef_params.cdef_y_sec_strength[1] = 2; fh.cdef_params.cdef_uv_pri_strength[1] = 12; fh.cdef_params.cdef_uv_sec_strength[1] = 2; fh.cdef_params.cdef_y_pri_strength[2] = 0; fh.cdef_params.cdef_y_sec_strength[2] = 0; fh.cdef_params.cdef_uv_pri_strength[2] = 0; fh.cdef_params.cdef_uv_sec_strength[2] = 0; fh.cdef_params.cdef_y_pri_strength[3] = 6; fh.cdef_params.cdef_y_sec_strength[3] = 0; fh.cdef_params.cdef_uv_pri_strength[3] = 6; fh.cdef_params.cdef_uv_sec_strength[3] = 0; fh.cdef_params.cdef_y_pri_strength[4] = 2; fh.cdef_params.cdef_y_sec_strength[4] = 0; fh.cdef_params.cdef_uv_pri_strength[4] = 2; fh.cdef_params.cdef_uv_sec_strength[4] = 0; fh.cdef_params.cdef_y_pri_strength[5] = 4; fh.cdef_params.cdef_y_sec_strength[5] = 1; fh.cdef_params.cdef_uv_pri_strength[5] = 4; fh.cdef_params.cdef_uv_sec_strength[5] = 1; fh.cdef_params.cdef_y_pri_strength[6] = 1; fh.cdef_params.cdef_y_sec_strength[6] = 0; fh.cdef_params.cdef_uv_pri_strength[6] = 1; fh.cdef_params.cdef_uv_sec_strength[6] = 0; fh.cdef_params.cdef_y_pri_strength[7] = 2; fh.cdef_params.cdef_y_sec_strength[7] = 1; fh.cdef_params.cdef_uv_pri_strength[7] = 2; fh.cdef_params.cdef_uv_sec_strength[7] = 1; fh.loop_filter_params.loop_filter_level[0] = 15; fh.loop_filter_params.loop_filter_level[1] = 15; fh.loop_filter_params.loop_filter_level[2] = 8; fh.loop_filter_params.loop_filter_level[3] = 8; fh.loop_filter_params.loop_filter_sharpness = 0; fh.loop_filter_params.loop_filter_delta_enabled = 0; fh.loop_filter_params.loop_filter_delta_update = 0; fh.TxMode = TX_MODE_SELECT; fh.reference_select = ips.LDB ? 1 : 0; fh.skipModeAllowed = 0; fh.skipModeFrame[0] = 0; fh.skipModeFrame[1] = 0; fh.allow_warped_motion = 0; fh.reduced_tx_set = 1; } // brief interface with va, render bitstream static void va_render_packed_data(bitstream* bs) { CHECK_BS_NULL(bs); VAEncPackedHeaderParameterBuffer packedheader_param_buffer; VABufferID packed_para_bufid = VA_INVALID_ID; VABufferID packed_data_bufid = VA_INVALID_ID; VABufferID render_id[2] = {VA_INVALID_ID}; unsigned int length_in_bits = bs->bit_offset; unsigned char *packedpic_buffer = bs->buffer; VAStatus va_status; packedheader_param_buffer.type = VAEncPackedHeaderPicture; packedheader_param_buffer.bit_length = length_in_bits; packedheader_param_buffer.has_emulation_bytes = 0; va_status = vaCreateBuffer(va_dpy, context_id, VAEncPackedHeaderParameterBufferType, sizeof(packedheader_param_buffer), 1, &packedheader_param_buffer, &packed_para_bufid); CHECK_VASTATUS(va_status, "vaCreateBuffer"); va_status = vaCreateBuffer(va_dpy, context_id, VAEncPackedHeaderDataBufferType, (length_in_bits + 7) / 8, 1, packedpic_buffer, &packed_data_bufid); CHECK_VASTATUS(va_status, "vaCreateBuffer"); render_id[0] = packed_para_bufid; render_id[1] = packed_data_bufid; va_status = vaRenderPicture(va_dpy, context_id, render_id, 2); CHECK_VASTATUS(va_status, "vaRenderPicture"); //free(packedpic_buffer); free outside this function call if (packed_para_bufid != VA_INVALID_ID) { vaDestroyBuffer(va_dpy, packed_para_bufid); packed_para_bufid = VA_INVALID_ID; } if (packed_data_bufid != VA_INVALID_ID) { vaDestroyBuffer(va_dpy, packed_data_bufid); packed_data_bufid = VA_INVALID_ID; } } static void render_ivf_frame_header() { // write 12 empty byte to driver // IVF frame header is filled after encoding // first 4 byte is u32 for bit stream length // last 8 byte is u64 for display order bitstream bs; bitstream_start(&bs); for (size_t i = 0; i < 12; i++) { put_ui(&bs, 0x00, 8); } va_render_packed_data(&bs); bitstream_free(&bs); } static void render_ivf_header() { bitstream bs; bitstream_start(&bs); uint32_t ivfSeqHeader[11] = {0x46494B44, 0x00200000, 0x31305641, (uint32_t)(fh.UpscaledWidth + (fh.FrameHeight << 16)), ips.frame_rate_extN,// FrameRateExtN ips.frame_rate_extD,// FrameRateExtD ips.frame_count/*numFramesInFile*/, 0x00000000, 0,0,0 }; // uint8_t* hdr = (uint8_t*) ivfSeqHeader; for (size_t i = 0; i < 44; i++) { put_ui(&bs, hdr[i], 8); } va_render_packed_data(&bs); bitstream_free(&bs); } static void render_TD() { // OBU_TEMPORAL_DELIMITER bitstream bs; bitstream_start(&bs); put_ui(&bs, 0x12, 8); put_ui(&bs, 0x00, 8); va_render_packed_data(&bs); bitstream_free(&bs); } static void build_sps_buffer(VAEncSequenceParameterBufferAV1* sps) { CHECK_NULL(sps); sps->seq_profile = (uint8_t)sh.seq_profile; sps->seq_level_idx = (uint8_t)(sh.seq_level_idx[0]); sps->intra_period = ips.intra_period; sps->ip_period = ips.ip_period; if (ips.RateControlMethod == VA_RC_CBR) { sps->bits_per_second = ips.target_bitrate; } else if (ips.RateControlMethod == VA_RC_VBR) { sps->bits_per_second = ips.vbr_max_bitrate; } sps->order_hint_bits_minus_1 = (uint8_t)(sh.order_hint_bits_minus1); sps->seq_fields.bits.still_picture = sh.still_picture; sps->seq_fields.bits.enable_filter_intra = sh.enable_filter_intra; sps->seq_fields.bits.enable_intra_edge_filter = sh.enable_intra_edge_filter; sps->seq_fields.bits.enable_interintra_compound = sh.enable_interintra_compound; sps->seq_fields.bits.enable_masked_compound = sh.enable_masked_compound; sps->seq_fields.bits.enable_warped_motion = sh.enable_warped_motion; sps->seq_fields.bits.enable_dual_filter = sh.enable_dual_filter; sps->seq_fields.bits.enable_order_hint = sh.enable_order_hint; sps->seq_fields.bits.enable_jnt_comp = sh.enable_jnt_comp; sps->seq_fields.bits.enable_ref_frame_mvs = sh.enable_ref_frame_mvs; sps->seq_fields.bits.enable_superres = sh.enable_superres; sps->seq_fields.bits.enable_cdef = sh.enable_cdef; sps->seq_fields.bits.enable_restoration = sh.enable_restoration; sps->seq_fields.bits.bit_depth_minus8 = ips.bit_depth - 8; sps->seq_fields.bits.subsampling_x = 0; sps->seq_fields.bits.subsampling_y = 0; } static void render_sequence() { VABufferID seq_param_buf_id = VA_INVALID_ID; VAStatus va_status; VAEncSequenceParameterBufferAV1 sps_buffer; memset(&sps_buffer, 0, sizeof(sps_buffer)); build_sps_buffer(&sps_buffer); va_status = vaCreateBuffer(va_dpy, context_id, VAEncSequenceParameterBufferType, sizeof(sps_buffer), 1, &sps_buffer, &seq_param_buf_id); CHECK_VASTATUS(va_status, "vaCreateBuffer");; va_status = vaRenderPicture(va_dpy, context_id, &seq_param_buf_id, 1); CHECK_VASTATUS(va_status, "vaRenderPicture"); if (seq_param_buf_id != VA_INVALID_ID) { vaDestroyBuffer(va_dpy, seq_param_buf_id); seq_param_buf_id = VA_INVALID_ID; } } static void render_rc_buffer() { VABufferID rc_param_buf = VA_INVALID_ID; VAStatus va_status; VABufferID render_id = VA_INVALID_ID; VAEncMiscParameterBuffer *misc_param; VAEncMiscParameterRateControl *misc_rate_ctrl; va_status = vaCreateBuffer(va_dpy, context_id, VAEncMiscParameterBufferType, sizeof(VAEncMiscParameterBuffer) + sizeof(VAEncMiscParameterRateControl), 1, NULL, &rc_param_buf); CHECK_VASTATUS(va_status, "vaCreateBuffer"); vaMapBuffer(va_dpy, rc_param_buf, (void **)&misc_param); misc_param->type = VAEncMiscParameterTypeRateControl; misc_rate_ctrl = (VAEncMiscParameterRateControl *)misc_param->data; memset(misc_rate_ctrl, 0, sizeof(*misc_rate_ctrl)); if (ips.RateControlMethod == VA_RC_CBR) { misc_rate_ctrl->bits_per_second = ips.target_bitrate; } else if (ips.RateControlMethod == VA_RC_VBR) { misc_rate_ctrl->bits_per_second = ips.vbr_max_bitrate; if (ips.target_bitrate != 0) { misc_rate_ctrl->target_percentage = MIN(100, (uint32_t) (100.0 * ips.target_bitrate / ips.vbr_max_bitrate)); } } vaUnmapBuffer(va_dpy, rc_param_buf); render_id = rc_param_buf; va_status = vaRenderPicture(va_dpy, context_id, &render_id, 1); CHECK_VASTATUS(va_status, "vaRenderPicture"); if (rc_param_buf != VA_INVALID_ID) { vaDestroyBuffer(va_dpy, rc_param_buf); rc_param_buf = VA_INVALID_ID; } } static void render_hrd_buffer() { VABufferID param_buf = VA_INVALID_ID; VAStatus va_status; VABufferID render_id = VA_INVALID_ID; VAEncMiscParameterBuffer *misc_param; VAEncMiscParameterHRD *misc_hrd; va_status = vaCreateBuffer(va_dpy, context_id, VAEncMiscParameterBufferType, sizeof(VAEncMiscParameterBuffer) + sizeof(VAEncMiscParameterHRD), 1, NULL, ¶m_buf); CHECK_VASTATUS(va_status, "vaCreateBuffer"); vaMapBuffer(va_dpy, param_buf, (void **)&misc_param); misc_param->type = VAEncMiscParameterTypeHRD; misc_hrd = (VAEncMiscParameterHRD *)misc_param->data; memset(misc_hrd, 0, sizeof(*misc_hrd)); misc_hrd->initial_buffer_fullness = ips.initial_buffer_fullness; misc_hrd->buffer_size = ips.buffer_size; vaUnmapBuffer(va_dpy, param_buf); render_id = param_buf; va_status = vaRenderPicture(va_dpy, context_id, &render_id, 1); CHECK_VASTATUS(va_status, "vaRenderPicture"); if (param_buf != VA_INVALID_ID) { vaDestroyBuffer(va_dpy, param_buf); param_buf = VA_INVALID_ID; } } static void render_fr_buffer() { VABufferID param_buf = VA_INVALID_ID; VAStatus va_status; VABufferID render_id = VA_INVALID_ID; VAEncMiscParameterBuffer *misc_param; VAEncMiscParameterFrameRate *misc_fr; va_status = vaCreateBuffer(va_dpy, context_id, VAEncMiscParameterBufferType, sizeof(VAEncMiscParameterBuffer) + sizeof(VAEncMiscParameterFrameRate), 1, NULL, ¶m_buf); CHECK_VASTATUS(va_status, "vaCreateBuffer"); vaMapBuffer(va_dpy, param_buf, (void **)&misc_param); misc_param->type = VAEncMiscParameterTypeFrameRate; misc_fr = (VAEncMiscParameterFrameRate *)misc_param->data; memset(misc_fr, 0, sizeof(*misc_fr)); misc_fr->framerate = ips.frame_rate_extN | (ips.frame_rate_extD << 16); vaUnmapBuffer(va_dpy, param_buf); render_id = param_buf; va_status = vaRenderPicture(va_dpy, context_id, &render_id, 1); CHECK_VASTATUS(va_status, "vaRenderPicture"); if (param_buf != VA_INVALID_ID) { vaDestroyBuffer(va_dpy, param_buf); param_buf = VA_INVALID_ID; } } static void render_misc_buffer() { render_rc_buffer(); if (ips.buffer_size != 0 || ips.initial_buffer_fullness != 0) { render_hrd_buffer(); } render_fr_buffer(); } static void render_tile_group() { VABufferID tile_param_buf_id = VA_INVALID_ID; VAStatus va_status; VAEncTileGroupBufferAV1 tile_group_buffer = {0}; //default setting va_status = vaCreateBuffer(va_dpy, context_id, VAEncSliceParameterBufferType, sizeof(tile_group_buffer), 1, &tile_group_buffer, &tile_param_buf_id); CHECK_VASTATUS(va_status, "vaCreateBuffer");; va_status = vaRenderPicture(va_dpy, context_id, &tile_param_buf_id, 1); CHECK_VASTATUS(va_status, "vaRenderPicture"); if (tile_param_buf_id != VA_INVALID_ID) { vaDestroyBuffer(va_dpy, tile_param_buf_id); tile_param_buf_id = VA_INVALID_ID; } } static void pack_obu_header(bitstream *bs, int obu_type, uint32_t obu_extension_flag) { put_ui(bs, 0, 1); //obu_forbidden_bit put_ui(bs, obu_type, 4); //type put_ui(bs, obu_extension_flag, 1); put_ui(bs, 1, 1); //obu_has_size_field put_ui(bs, 0, 1); //reserved if (obu_extension_flag) { // Obu Extension Header // not written to bitstream by default } } static void pack_obu_header_size(bitstream *bs, uint32_t value, uint8_t fixed_output_len) { // pack leb128 uint64_t leb128_buf = 0; uint8_t leb128_size = 0; uint8_t* buf = (uint8_t*)(&leb128_buf); if (!fixed_output_len) { // general encoding do { buf[leb128_size] = value & 0x7fU; if (value >>= 7) { buf[leb128_size] |= 0x80U; } leb128_size++; } while (value); } else { // get fixed len of output, in this case, LEB128 will have fixed length uint8_t value_byte_count = 0; do { buf[value_byte_count++] = value & 0x7fU; value >>= 7; } while (value); for (int i = 0; i < fixed_output_len - 1; i++) { buf[i] |= 0x80U; leb128_size++; } leb128_size++; } // write to bitstream const uint8_t* ptr = (uint8_t*)(&leb128_buf); for (uint8_t i = 0; i < leb128_size; i++) put_ui(bs, ptr[i], 8); } static void pack_operating_points(bitstream* bs) { put_ui(bs, sh.operating_points_cnt_minus_1, 5); for(uint8_t i = 0;i <= sh.operating_points_cnt_minus_1;i++) { //put_ui(bs, sh.operating_point_idc[i], 12); put_ui(bs, sh.operating_point_idc[i] >> 4, 8); put_ui(bs, sh.operating_point_idc[i] & 0x9f, 4); put_ui(bs, sh.seq_level_idx[i], 5); if(sh.seq_level_idx[i]>7) put_ui(bs, sh.seq_tier[i], 1); } } static void pack_frame_size_info(bitstream* bs) { //pack frame size info put_ui(bs, 15, 4);//frame_width_bits_minus_1 put_ui(bs, 15, 4);//frame_height_bits_minus_1 put_ui(bs, fh.UpscaledWidth - 1, 16);//max_frame_width_minus_1 put_ui(bs, fh.FrameHeight - 1, 16);//max_frame_height_minus_1 // end of pack frame size info } static void pack_seq_data(bitstream *bs) { put_ui(bs, sh.seq_profile, 3); put_ui(bs, sh.still_picture, 1); put_ui(bs, 0, 1);//reduced_still_picture_header put_ui(bs, 0, 1);//timing_info_present_flag put_ui(bs, 0, 1);//initial_display_delay_present_flag pack_operating_points(bs); pack_frame_size_info(bs); put_ui(bs, 0, 1);//frame_id_numbers_present_flag (affects FH) put_ui(bs, 0, 1);//use_128x128_superblock put_ui(bs, sh.enable_filter_intra, 1);//enable_filter_intra put_ui(bs, sh.enable_intra_edge_filter, 1);//enable_intra_edge_filter put_ui(bs, sh.enable_interintra_compound, 1);//enable_interintra_compound put_ui(bs, sh.enable_masked_compound, 1);//enable_masked_compound put_ui(bs, sh.enable_warped_motion, 1);//enable_warped_motion put_ui(bs, sh.enable_dual_filter, 1);//enable_dual_filter put_ui(bs, sh.enable_order_hint, 1);//enable_order_hint if (sh.enable_order_hint) { put_ui(bs, 0, 1); //enable_jnt_comp put_ui(bs, fh.use_ref_frame_mvs, 1);//enable_ref_frame_mvs } put_ui(bs, 1, 1);//seq_choose_screen_content_tools put_ui(bs, sh.seq_force_integer_mv, 1);//seq_choose_integer_mv if (!sh.seq_force_integer_mv) { put_ui(bs, 0, 1); //seq_force_integer_mv } if (sh.enable_order_hint) { put_ui(bs, sh.order_hint_bits_minus1, 3);//affects FH } put_ui(bs, sh.enable_superres, 1);//enable_superres put_ui(bs, sh.enable_cdef, 1);//enable_cdef put_ui(bs, sh.enable_restoration, 1);//enable_restoration // pack color config put_ui(bs, sh.color_config.BitDepth == BITDEPTH_10 ? 1 : 0, 1); if (sh.seq_profile != 1) put_ui(bs, 0, 1);; //mono_chrome put_ui(bs, sh.color_config.color_description_present_flag, 1); if (sh.color_config.color_description_present_flag) { put_ui(bs, sh.color_config.color_primaries, 8); put_ui(bs, sh.color_config.transfer_characteristics, 8); put_ui(bs, sh.color_config.matrix_coefficients, 8); } put_ui(bs, sh.color_config.color_range, 1);//color_range if (sh.seq_profile == 0) put_ui(bs, 0, 2); //chroma_sample_position put_ui(bs, sh.color_config.separate_uv_delta_q, 1); //separate_uv_delta_q put_ui(bs, 0, 1);//film_grain_params_present put_trailing_bits(bs); } static void build_packed_seq_header(bitstream* bs) { CHECK_BS_NULL(bs); CHECK_CONDITION(bs->bit_offset == 0); // handle vairable length // seq obu data bitstream obu_data; bitstream_start(&obu_data); pack_seq_data(&obu_data); uint32_t obu_extension_flag = sh.operating_points_cnt_minus_1 ? 1 : 0; pack_obu_header(bs, OBU_SEQUENCE_HEADER, obu_extension_flag); //calculate data size uint32_t obu_size_in_bytes = (obu_data.bit_offset + 7) / 8; pack_obu_header_size(bs, obu_size_in_bytes, 0); bitstream_cat(bs, &obu_data); } static int render_packedsequence() { int len; bitstream bs; bitstream_start(&bs); build_packed_seq_header(&bs); len = (bs.bit_offset + 7) / 8; va_render_packed_data(&bs); bitstream_free(&bs); return len; } static void pack_show_existing_frame(bitstream* bs) { return; //only for B frame, not enable by default } static void pack_show_frame(bitstream* bs) { put_ui(bs, fh.show_frame, 1); if(!fh.show_frame) put_ui(bs, fh.showable_frame, 1); } static void pack_error_resilient(bitstream* bs) { if (!(fh.frame_type == SWITCH_FRAME || (fh.frame_type == KEY_FRAME && fh.show_frame))) put_ui(bs, 0, 1); //error_resilient_mode } static void pack_ref_frame_flags(bitstream* bs, uint8_t error_resilient_mode, uint8_t isI) { if(!(isI || error_resilient_mode)) put_ui(bs, 0, 3); //primary_ref_frame if (!(fh.frame_type == SWITCH_FRAME || (fh.frame_type == KEY_FRAME && fh.show_frame))) put_ui(bs, fh.refresh_frame_flags, NUM_REF_FRAMES); } static void pack_interpolation_filter(bitstream* bs) { const uint8_t is_filter_switchable = (fh.interpolation_filter == 4 ? 1 : 0); put_ui(bs, is_filter_switchable, 1);//is_filter_switchable if (!is_filter_switchable) { put_ui(bs, fh.interpolation_filter, 2);//interpolation_filter } } static void pack_render_size(bitstream* bs) { uint32_t render_and_frame_size_different = 0; put_ui(bs, render_and_frame_size_different, 1);//render_and_frame_size_different } static void pack_frame_size(bitstream *bs) { if (fh.frame_size_override_flag) { put_ui(bs, fh.UpscaledWidth - 1, sh.frame_width_bits + 1); //frame_width_minus_1 put_ui(bs, fh.FrameHeight - 1, sh.frame_height_bits + 1); //frame_height_minus_1 } } static void pack_frame_size_with_refs(bitstream* bs) { CHECK_BS_NULL(bs); uint32_t found_ref = 0; for (int8_t ref = 0; ref < REFS_PER_FRAME; ref++) put_ui(bs, found_ref, 1);//found_ref // if found_ref == 9 pack_frame_size(bs); pack_render_size(bs); } static void pack_frame_ref_info(bitstream* bs, uint8_t error_resilient_mode) { if (sh.enable_order_hint) put_ui(bs, 0, 1); //frame_refs_short_signaling for (uint8_t ref = 0; ref < REFS_PER_FRAME; ref++) put_ui(bs, fh.ref_frame_idx[ref], REF_FRAMES_LOG2); if (fh.frame_size_override_flag && !error_resilient_mode) { pack_frame_size_with_refs(bs); } else { pack_frame_size(bs); pack_render_size(bs); } put_ui(bs, fh.allow_high_precision_mv, 1); //allow_high_precision_mv //PackInterpolationFilter(bs, fh); pack_interpolation_filter(bs); put_ui(bs, 0, 1);//is_motion_switchable if (fh.use_ref_frame_mvs) put_ui(bs, 1, 1); //use_ref_frame_mvs } static void pack_tile_info(bitstream* bs) { // use single tile by default put_ui(bs, 1, 1);//uniform_tile_spacing_flag put_ui(bs, 0, 1);//increment_tile_cols_log2 put_ui(bs, 0, 1);//increment_tile_rows_log2 } static uint16_t write_SU(int32_t value, uint16_t n) { int16_t signMask = 1 << (n - 1); if (value & signMask) { value = value - 2 * signMask; } return value; } static void pack_delta_q_value(bitstream* bs, int32_t deltaQ) { if (deltaQ) { put_ui(bs, 1, 1); put_ui(bs, write_SU(deltaQ, 7), 7); } else put_ui(bs, 0, 1); } static void pack_quantization_params(bitstream* bs) { put_ui(bs, fh.quantization_params.base_q_idx, 8); //base_q_idx pack_delta_q_value(bs, fh.quantization_params.DeltaQYDc); bool diff_uv_delta = false; if (fh.quantization_params.DeltaQUDc != fh.quantization_params.DeltaQVDc || fh.quantization_params.DeltaQUAc != fh.quantization_params.DeltaQVAc) diff_uv_delta = true; if (sh.color_config.separate_uv_delta_q) put_ui(bs, diff_uv_delta, 1); pack_delta_q_value(bs, fh.quantization_params.DeltaQUDc); pack_delta_q_value(bs, fh.quantization_params.DeltaQUAc); if (diff_uv_delta) { pack_delta_q_value(bs, fh.quantization_params.DeltaQVDc); pack_delta_q_value(bs, fh.quantization_params.DeltaQVAc); } put_ui(bs, fh.quantization_params.using_qmatrix, 1);//using_qmatrix if (fh.quantization_params.using_qmatrix) { put_ui(bs, fh.quantization_params.qm_y, 4); put_ui(bs, fh.quantization_params.qm_u, 4); if (sh.color_config.separate_uv_delta_q) put_ui(bs, fh.quantization_params.qm_v, 4); } } static void pack_loop_filter_params(bitstream* bs) { if (fh.CodedLossless || fh.allow_intrabc) return; put_ui(bs, fh.loop_filter_params.loop_filter_level[0], 6);//loop_filter_level[0] put_ui(bs, fh.loop_filter_params.loop_filter_level[1], 6);//loop_filter_level[1] if (fh.loop_filter_params.loop_filter_level[0] || fh.loop_filter_params.loop_filter_level[1]) { put_ui(bs, fh.loop_filter_params.loop_filter_level[2], 6);//loop_filter_level[2] put_ui(bs, fh.loop_filter_params.loop_filter_level[3], 6);//loop_filter_level[3] } put_ui(bs, fh.loop_filter_params.loop_filter_sharpness, 3); //loop_filter_sharpness put_ui(bs, 0, 1); //loop_filter_delta_enabled } static void pack_cdef_params(bitstream* bs) { if (!sh.enable_cdef || fh.CodedLossless || fh.allow_intrabc) return; uint16_t num_planes = sh.color_config.mono_chrome ? 1 : 3; put_ui(bs, fh.cdef_params.cdef_damping - 3, 2);//cdef_damping_minus_3 put_ui(bs, fh.cdef_params.cdef_bits, 2);//cdef_bits for (uint16_t i = 0; i < (1 << fh.cdef_params.cdef_bits); ++i) { put_ui(bs, fh.cdef_params.cdef_y_pri_strength[i], 4);//cdef_y_pri_strength[0] put_ui(bs, fh.cdef_params.cdef_y_sec_strength[i], 2);//cdef_y_sec_strength[0] if (num_planes > 1) { put_ui(bs, fh.cdef_params.cdef_uv_pri_strength[i], 4);//cdef_uv_pri_strength[0] put_ui(bs, fh.cdef_params.cdef_uv_sec_strength[i], 2);//cdef_uv_sec_strength[0] } } } static void pack_lr_params(bitstream* bs) { if (fh.AllLossless || fh.allow_intrabc || !sh.enable_restoration) return; bool usesLR = false; bool usesChromaLR = false; for (int i = 0; i < MAX_MB_PLANE; i++) { put_ui(bs, fh.lr_params.lr_type[i], 2); if (fh.lr_params.lr_type[i] != RESTORE_NONE) { usesLR = true; if (i > 0) { usesChromaLR = true; } } } if (usesLR) { put_ui(bs, fh.lr_params.lr_unit_shift, 1); if (sh.sbSize != 1 && fh.lr_params.lr_unit_shift) { put_ui(bs, fh.lr_params.lr_unit_extra_shift, 1); } if (sh.color_config.subsampling_x && sh.color_config.subsampling_y && usesChromaLR) { put_ui(bs, fh.lr_params.lr_uv_shift, 1); } } } static void pack_delta_q_params(bitstream* bs) { if (fh.quantization_params.base_q_idx) put_ui(bs, fh.delta_q_present, 1); //delta_q_present if (fh.delta_q_present) { put_ui(bs, 0, 2); //delta_q_res put_ui(bs, fh.delta_lf_present, 1); //delta_lf_present put_ui(bs, 0, 2); //delta_lf_res put_ui(bs, fh.delta_lf_multi, 1); //delta_lf_multi } } static void pack_frame_reference_mode(bitstream* bs, bool frameIsIntra) { if (frameIsIntra) return; put_ui(bs, fh.reference_select, 1); //reference_select } static void pack_skip_mode_params(bitstream* bs) { if (fh.skipModeAllowed) put_ui(bs, fh.skip_mode_present, 1); //skip_mode_present } static void pack_wrapped_motion(bitstream* bs, bool frameIsIntra) { if (frameIsIntra) return; if (sh.enable_warped_motion) put_ui(bs, 0, 1); //allow_warped_motion } static void pack_global_motion_params(bitstream* bs, bool frameIsIntra) { if (frameIsIntra) return; for (uint8_t i = LAST_FRAME; i <= ALTREF_FRAME; i++) put_ui(bs, 0, 1); //is_global[7] } static void pack_frame_header(bitstream* bs) { const uint8_t isI = (fh.frame_type == INTRA_ONLY_FRAME || fh.frame_type == KEY_FRAME); put_ui(bs, fh.frame_type, 2); pack_show_frame(bs); uint8_t error_resilient_mode = 0; pack_error_resilient(bs); put_ui(bs, fh.disable_cdf_update, 1); put_ui(bs, fh.allow_screen_content_tools, 1); put_ui(bs, fh.frame_size_override_flag, 1); // pack order hint if(sh.enable_order_hint) put_ui(bs, fh.order_hint, sh.order_hint_bits_minus1 + 1); // PackRefFrameFlags pack_ref_frame_flags(bs, error_resilient_mode, isI); if (!isI) { pack_frame_ref_info(bs, error_resilient_mode); } else { pack_frame_size(bs); pack_render_size(bs); if (fh.allow_screen_content_tools && fh.UpscaledWidth == fh.FrameWidth) put_ui(bs, fh.allow_intrabc, 1); } if (!fh.disable_cdf_update) put_ui(bs, fh.disable_frame_end_update_cdf, 1); //disable_frame_end_update_cdf pack_tile_info(bs); //quantization_params offsets.QIndexBitOffset = bs->bit_offset; pack_quantization_params(bs); //segmentation_params offsets.SegmentationBitOffset = bs->bit_offset; put_ui(bs, 0, 1); //segmentation_enabled offsets.SegmentationBitSize = bs->bit_offset - offsets.SegmentationBitOffset; pack_delta_q_params(bs); offsets.LoopFilterParamsBitOffset = bs->bit_offset; pack_loop_filter_params(bs); offsets.CDEFParamsBitOffset = bs->bit_offset; pack_cdef_params(bs); offsets.CDEFParamsSizeInBits = bs->bit_offset - offsets.CDEFParamsBitOffset; pack_lr_params(bs); const uint8_t tx_mode_select = fh.TxMode ? 1 : 0; if (!fh.CodedLossless) put_ui(bs, tx_mode_select, 1); //tx_mode_select pack_frame_reference_mode(bs, isI); pack_skip_mode_params(bs); pack_wrapped_motion(bs, isI); put_ui(bs, fh.reduced_tx_set, 1); //reduced_tx_set pack_global_motion_params(bs, isI); } static void build_packed_pic_header(bitstream* bs) { // handle vairable length // pack obu payload and then put header // pic obu data bitstream tmp; bitstream_start(&tmp); put_ui(&tmp, fh.show_existing_frame, 1); //show_existing_frame if (fh.show_existing_frame) pack_show_existing_frame(&tmp); // only for B frame else pack_frame_header(&tmp); offsets.FrameHdrOBUSizeInBits = tmp.bit_offset; const uint32_t obu_extension_flag = sh.operating_points_cnt_minus_1 ? 1 : 0; const uint32_t obu_header_offset = bs->bit_offset; put_aligning_bits(&tmp); pack_obu_header(bs, OBU_FRAME, obu_extension_flag); offsets.FrameHdrOBUSizeByteOffset = (bs->bit_offset >> 3) + len_ivf_header + 2 + len_seq_header; // first frame with IVF header const uint32_t obu_size_in_bytes = (tmp.bit_offset + 7) / 8; pack_obu_header_size(bs, obu_size_in_bytes, fh.show_existing_frame? 0: 4); if (!fh.show_existing_frame) { // The offset is related to frame or frame header OBU. IVF, sequence, and other headers should not be counted. const uint32_t obuPayloadOffset = bs->bit_offset - obu_header_offset; offsets.QIndexBitOffset += obuPayloadOffset; offsets.SegmentationBitOffset += obuPayloadOffset; offsets.LoopFilterParamsBitOffset += obuPayloadOffset; offsets.CDEFParamsBitOffset += obuPayloadOffset; //offsets.CDEFParamsSizeInBits is not needed to be updated. offsets.FrameHdrOBUSizeInBits += obuPayloadOffset; } bitstream_cat(bs, &tmp); } static void render_packedpicture() { bitstream bs; bitstream_start(&bs); build_packed_pic_header(&bs); va_render_packed_data(&bs); bitstream_free(&bs); } static void fill_ref_params(VAEncPictureParameterBufferAV1* pps) { CHECK_NULL(pps); if(fh.frame_type == KEY_FRAME) { return; } else if(fh.frame_type == INTER_FRAME) { // use last frame as reference pps->reference_frames[0] = ref_surface[((current_frame_display - 1) % SURFACE_NUM)]; pps->ref_frame_ctrl_l0.fields.search_idx0 = LAST_FRAME; // for Low delay B pps->ref_frame_ctrl_l1.fields.search_idx0 = ips.LDB ? BWDREF_FRAME : INTRA_FRAME; } } static void build_pps_buffer(VAEncPictureParameterBufferAV1* pps) { CHECK_NULL(pps); // InitPPS memset(&(pps->reference_frames), VA_INVALID_ID, 8); //frame size pps->frame_height_minus_1 =(uint16_t)(fh.FrameHeight - 1); pps->frame_width_minus_1 = (uint16_t)(fh.UpscaledWidth - 1); //bitstream pps->coded_buf = coded_buf[current_slot]; for(int k = 0; k < REFS_PER_FRAME; k++) pps->ref_frame_idx[k] = 0; pps->picture_flags.bits.use_ref_frame_mvs = fh.use_ref_frame_mvs; pps->picture_flags.bits.long_term_reference = 0; pps->picture_flags.bits.allow_intrabc = fh.allow_intrabc; pps->seg_id_block_size = 0; //quantizer pps->y_dc_delta_q = (uint8_t)(fh.quantization_params.DeltaQYDc); pps->u_dc_delta_q = (uint8_t)(fh.quantization_params.DeltaQUDc); pps->u_ac_delta_q = (uint8_t)(fh.quantization_params.DeltaQUAc); pps->v_dc_delta_q = (uint8_t)(fh.quantization_params.DeltaQVDc); pps->v_ac_delta_q = (uint8_t)(fh.quantization_params.DeltaQVAc); //other params pps->picture_flags.bits.error_resilient_mode = fh.error_resilient_mode; pps->interpolation_filter = (uint8_t)(fh.interpolation_filter); pps->picture_flags.bits.use_superres = fh.use_superres; pps->picture_flags.bits.allow_high_precision_mv = fh.allow_high_precision_mv; pps->picture_flags.bits.reduced_tx_set = fh.reduced_tx_set; pps->picture_flags.bits.palette_mode_enable = fh.allow_screen_content_tools; //tx_mod pps->mode_control_flags.bits.tx_mode = fh.TxMode; pps->temporal_id = 0; pps->superres_scale_denominator = (uint8_t)(fh.SuperresDenom); //q_matrix pps->qmatrix_flags.bits.using_qmatrix = fh.quantization_params.using_qmatrix; pps->qmatrix_flags.bits.qm_y = fh.quantization_params.qm_y; pps->qmatrix_flags.bits.qm_u = fh.quantization_params.qm_u; pps->qmatrix_flags.bits.qm_v = fh.quantization_params.qm_v; pps->picture_flags.bits.frame_type = fh.frame_type; pps->base_qindex = (uint8_t)fh.quantization_params.base_q_idx; pps->min_base_qindex = ips.MinBaseQIndex; pps->max_base_qindex = ips.MaxBaseQIndex; pps->order_hint = (uint8_t)(fh.order_hint); //reference frame pps->primary_ref_frame = (uint8_t)(fh.primary_ref_frame); pps->ref_frame_ctrl_l0.value = 0; pps->ref_frame_ctrl_l1.value = 0; fill_ref_params(pps); pps->refresh_frame_flags = fh.refresh_frame_flags; // //loop filter // auto& lf = fh.loop_filter_params; pps->filter_level[0] = (uint8_t)(fh.loop_filter_params.loop_filter_level[0]); pps->filter_level[1] = (uint8_t)(fh.loop_filter_params.loop_filter_level[1]); pps->filter_level_u = (uint8_t)(fh.loop_filter_params.loop_filter_level[2]); pps->filter_level_v = (uint8_t)(fh.loop_filter_params.loop_filter_level[3]); pps->loop_filter_flags.bits.sharpness_level = fh.loop_filter_params.loop_filter_sharpness; pps->loop_filter_flags.bits.mode_ref_delta_enabled = fh.loop_filter_params.loop_filter_delta_enabled; pps->loop_filter_flags.bits.mode_ref_delta_update = fh.loop_filter_params.loop_filter_delta_update; for(int k = 0;k < 8;k++) pps->ref_deltas[k] = 0; //block-level deltas pps->mode_control_flags.bits.delta_q_present = fh.delta_q_present; pps->mode_control_flags.bits.delta_q_res = fh.delta_q_res; pps->mode_control_flags.bits.delta_lf_res = fh.delta_lf_res; pps->mode_control_flags.bits.delta_lf_present = fh.delta_lf_present; pps->mode_control_flags.bits.delta_lf_multi = fh.delta_lf_multi; pps->mode_control_flags.bits.reference_mode = fh.reference_select ? REFERENCE_MODE_SELECT : SINGLE_REFERENCE; pps->mode_control_flags.bits.skip_mode_present = fh.skip_mode_present; //tile pps->tile_cols = 1; pps->width_in_sbs_minus_1[0] = (uint16_t)(((fh.UpscaledWidth+63)&(~63))/64 - 1); pps->tile_rows = 1; pps->height_in_sbs_minus_1[0] = (uint16_t)(((fh.FrameHeight+63)&(~63))/64 - 1); pps->context_update_tile_id = (uint8_t)(fh.tile_info.context_update_tile_id); //cdef if(sh.enable_cdef) { pps->cdef_damping_minus_3 = (uint8_t)(fh.cdef_params.cdef_damping - 3); pps->cdef_bits = (uint8_t)(fh.cdef_params.cdef_bits); for (uint8_t i = 0; i < CDEF_MAX_STRENGTHS; i++) { pps->cdef_y_strengths[i] = (uint8_t)(fh.cdef_params.cdef_y_pri_strength[i] * CDEF_STRENGTH_DIVISOR + fh.cdef_params.cdef_y_sec_strength[i]); pps->cdef_uv_strengths[i] = (uint8_t)(fh.cdef_params.cdef_uv_pri_strength[i] * CDEF_STRENGTH_DIVISOR + fh.cdef_params.cdef_uv_sec_strength[i]); } } //loop restoration pps->loop_restoration_flags.bits.yframe_restoration_type = (fh.lr_params.lr_type[0] == RESTORE_WIENER) ? 1 : 0; pps->loop_restoration_flags.bits.cbframe_restoration_type = (fh.lr_params.lr_type[1] == RESTORE_WIENER) ? 1 : 0; pps->loop_restoration_flags.bits.crframe_restoration_type = (fh.lr_params.lr_type[2] == RESTORE_WIENER) ? 1 : 0; pps->loop_restoration_flags.bits.lr_unit_shift = fh.lr_params.lr_unit_shift; pps->loop_restoration_flags.bits.lr_uv_shift = fh.lr_params.lr_uv_shift; //context pps->picture_flags.bits.disable_cdf_update = fh.disable_cdf_update; pps->picture_flags.bits.disable_frame_end_update_cdf = fh.disable_frame_end_update_cdf; pps->picture_flags.bits.disable_frame_recon = (fh.refresh_frame_flags == 0); pps->num_tile_groups_minus1 = 0; pps->tile_group_obu_hdr_info.bits.obu_extension_flag = 0; pps->tile_group_obu_hdr_info.bits.obu_has_size_field = 1; pps->tile_group_obu_hdr_info.bits.temporal_id = 0; pps->tile_group_obu_hdr_info.bits.spatial_id = 0; //other params pps->picture_flags.bits.error_resilient_mode = fh.error_resilient_mode; pps->picture_flags.bits.enable_frame_obu = 1; pps->reconstructed_frame = ref_surface[current_slot]; //offsets need update pps->size_in_bits_frame_hdr_obu = offsets.FrameHdrOBUSizeInBits; pps->byte_offset_frame_hdr_obu_size = offsets.FrameHdrOBUSizeByteOffset; pps->bit_offset_loopfilter_params = offsets.LoopFilterParamsBitOffset; pps->bit_offset_qindex = offsets.QIndexBitOffset; pps->bit_offset_segmentation = offsets.SegmentationBitOffset; pps->bit_offset_cdef_params = offsets.CDEFParamsBitOffset; pps->size_in_bits_cdef_params = offsets.CDEFParamsSizeInBits; //q_matrix pps->qmatrix_flags.bits.using_qmatrix = fh.quantization_params.using_qmatrix; pps->qmatrix_flags.bits.qm_y = fh.quantization_params.qm_y; pps->qmatrix_flags.bits.qm_u = fh.quantization_params.qm_u; pps->qmatrix_flags.bits.qm_v = fh.quantization_params.qm_v; pps->skip_frames_reduced_size = 0; } static void render_picture() { VABufferID pic_param_buf_id = VA_INVALID_ID; VAStatus va_status; VAEncPictureParameterBufferAV1 pps_buffer; memset(&pps_buffer, 0, sizeof(pps_buffer)); build_pps_buffer(&pps_buffer); va_status = vaCreateBuffer(va_dpy, context_id, VAEncPictureParameterBufferType, sizeof(pps_buffer), 1, &pps_buffer, &pic_param_buf_id); CHECK_VASTATUS(va_status, "vaCreateBuffer");; va_status = vaRenderPicture(va_dpy, context_id, &pic_param_buf_id, 1); CHECK_VASTATUS(va_status, "vaRenderPicture"); if (pic_param_buf_id != VA_INVALID_ID) { vaDestroyBuffer(va_dpy, pic_param_buf_id); pic_param_buf_id = VA_INVALID_ID; } } static int upload_source_YUV_once_for_all() { int box_width = 8; int row_shift = 0; int i; for (i = 0; i < SURFACE_NUM; i++) { printf("\rLoading data into surface %d.....", i); upload_surface(va_dpy, src_surface[i], box_width, row_shift, 0); row_shift++; if (row_shift == (2 * box_width)) row_shift = 0; } printf("Complete surface loading\n"); return 0; } static struct storage_task_t * storage_task_dequeue(void) { struct storage_task_t *header; pthread_mutex_lock(&encode_mutex); header = storage_task_header; if (storage_task_header != NULL) { if (storage_task_tail == storage_task_header) storage_task_tail = NULL; storage_task_header = header->next; } pthread_mutex_unlock(&encode_mutex); return header; } static int load_surface(VASurfaceID surface_id, unsigned long long display_order) { unsigned char *srcyuv_ptr = NULL, *src_Y = NULL, *src_U = NULL, *src_V = NULL; unsigned long long frame_start, mmap_start; char *mmap_ptr = NULL; int frame_size, mmap_size; if (srcyuv_fp == NULL) return 0; /* allow encoding more than srcyuv_frames */ display_order = display_order % srcyuv_frames; frame_size = ips.width * ips.height * 3 / 2; /* for YUV420 */ frame_start = display_order * frame_size; mmap_start = frame_start & (~0xfff); mmap_size = (frame_size + (frame_start & 0xfff) + 0xfff) & (~0xfff); mmap_ptr = mmap(0, mmap_size, PROT_READ, MAP_SHARED, fileno(srcyuv_fp), mmap_start); if (mmap_ptr == MAP_FAILED) { printf("Failed to mmap YUV file (%s)\n", strerror(errno)); return 1; } srcyuv_ptr = (unsigned char *)mmap_ptr + (frame_start & 0xfff); if (srcyuv_fourcc == VA_FOURCC_NV12) { src_Y = srcyuv_ptr; src_U = src_Y + ips.width * ips.height; src_V = NULL; } else if (srcyuv_fourcc == VA_FOURCC_IYUV || srcyuv_fourcc == VA_FOURCC_YV12) { src_Y = srcyuv_ptr; if (srcyuv_fourcc == VA_FOURCC_IYUV) { src_U = src_Y + ips.width * ips.height; src_V = src_U + (ips.width / 2) * (ips.height / 2); } else { /* YV12 */ src_V = src_Y + ips.width * ips.height; src_U = src_V + (ips.width / 2) * (ips.height / 2); } } else { printf("Unsupported source YUV format\n"); exit(1); } upload_surface_yuv(va_dpy, surface_id, srcyuv_fourcc, ips.width, ips.height, src_Y, src_U, src_V); if (mmap_ptr) munmap(mmap_ptr, mmap_size); return 0; } static int save_codeddata(unsigned long long display_order, unsigned long long encode_order) { VACodedBufferSegment *buf_list = NULL; VAStatus va_status; int ret; unsigned int coded_size = 0; va_status = vaMapBuffer(va_dpy, coded_buf[display_order % SURFACE_NUM], (void **)(&buf_list)); CHECK_VASTATUS(va_status, "vaMapBuffer"); long frame_start = ftell(coded_fp); while (buf_list != NULL) { coded_size += fwrite(buf_list->buf, 1, buf_list->size, coded_fp); buf_list = (VACodedBufferSegment *) buf_list->next; frame_size += coded_size; } long frame_end = ftell(coded_fp); vaUnmapBuffer(va_dpy, coded_buf[display_order % SURFACE_NUM]); CHECK_CONDITION(frame_start >= 0 && frame_end >= 0); if(encode_order == 0) { //first frame unsigned int ivf_size = coded_size - 32 - 12; ret = fseek(coded_fp, frame_start + 32, SEEK_SET); CHECK_CONDITION(ret == 0); fwrite(&ivf_size, 4, 1, coded_fp); fwrite(&display_order, 8, 1, coded_fp); ret = fseek(coded_fp, frame_end, SEEK_SET); CHECK_CONDITION(ret == 0); } else { //other frames unsigned int ivf_size = coded_size - 12; ret = fseek(coded_fp, frame_start, SEEK_SET); CHECK_CONDITION(ret == 0); fwrite(&ivf_size, 4, 1, coded_fp); fwrite(&display_order, 8, 1, coded_fp); ret = fseek(coded_fp, frame_end, SEEK_SET); CHECK_CONDITION(ret == 0); } printf("\n "); /* return back to startpoint */ switch (encode_order % 4) { case 0: printf("|"); break; case 1: printf("/"); break; case 2: printf("-"); break; case 3: printf("\\"); break; } printf("%08lld", encode_order); printf("(%06d bytes coded)\n", coded_size); fflush(coded_fp); return 0; } static int save_recyuv(VASurfaceID surface_id, unsigned long long display_order, unsigned long long encode_order) { unsigned char *dst_Y = NULL, *dst_U = NULL, *dst_V = NULL; if (recyuv_fp == NULL) return 0; if (srcyuv_fourcc == VA_FOURCC_NV12) { int uv_size = 2 * (ips.width / 2) * (ips.height / 2); dst_Y = malloc(2 * uv_size); if (dst_Y == NULL) { printf("Failed to allocate memory for dst_Y\n"); exit(1); } dst_U = malloc(uv_size); if (dst_U == NULL) { printf("Failed to allocate memory for dst_U\n"); free(dst_Y); exit(1); } memset(dst_Y, 0, 2 * uv_size); memset(dst_U, 0, uv_size); } else if (srcyuv_fourcc == VA_FOURCC_IYUV || srcyuv_fourcc == VA_FOURCC_YV12) { int uv_size = (ips.width / 2) * (ips.height / 2); dst_Y = malloc(4 * uv_size); if (dst_Y == NULL) { printf("Failed to allocate memory for dst_Y\n"); exit(1); } dst_U = malloc(uv_size); if (dst_U == NULL) { printf("Failed to allocate memory for dst_U\n"); free(dst_Y); exit(1); } dst_V = malloc(uv_size); if (dst_V == NULL) { printf("Failed to allocate memory for dst_V\n"); free(dst_Y); free(dst_U); exit(1); } memset(dst_Y, 0, 4 * uv_size); memset(dst_U, 0, uv_size); memset(dst_V, 0, uv_size); } else { printf("Unsupported source YUV format\n"); exit(1); } download_surface_yuv(va_dpy, surface_id, srcyuv_fourcc, ips.width, ips.height, dst_Y, dst_U, dst_V); fseek(recyuv_fp, display_order * ips.width * ips.height * 1.5, SEEK_SET); if (srcyuv_fourcc == VA_FOURCC_NV12) { int uv_size = 2 * (ips.width / 2) * (ips.height / 2); fwrite(dst_Y, uv_size * 2, 1, recyuv_fp); fwrite(dst_U, uv_size, 1, recyuv_fp); } else if (srcyuv_fourcc == VA_FOURCC_IYUV || srcyuv_fourcc == VA_FOURCC_YV12) { int uv_size = (ips.width / 2) * (ips.height / 2); fwrite(dst_Y, uv_size * 4, 1, recyuv_fp); if (srcyuv_fourcc == VA_FOURCC_IYUV) { fwrite(dst_U, uv_size, 1, recyuv_fp); fwrite(dst_V, uv_size, 1, recyuv_fp); } else { fwrite(dst_V, uv_size, 1, recyuv_fp); fwrite(dst_U, uv_size, 1, recyuv_fp); } } if (dst_Y) free(dst_Y); if (dst_U) free(dst_U); if (dst_V) free(dst_V); fflush(recyuv_fp); return 0; } static void storage_task(unsigned long long display_order, unsigned long long encode_order) { unsigned int tmp; VAStatus va_status; tmp = GetTickCount(); va_status = vaSyncSurface(va_dpy, src_surface[display_order % SURFACE_NUM]); CHECK_VASTATUS(va_status, "vaSyncSurface"); SyncPictureTicks += GetTickCount() - tmp; tmp = GetTickCount(); save_codeddata(display_order, encode_order); SavePictureTicks += GetTickCount() - tmp; save_recyuv(ref_surface[display_order % SURFACE_NUM], display_order, encode_order); /* reload a new frame data */ tmp = GetTickCount(); if (srcyuv_fp != NULL) load_surface(src_surface[display_order % SURFACE_NUM], display_order + SURFACE_NUM); UploadPictureTicks += GetTickCount() - tmp; pthread_mutex_lock(&encode_mutex); srcsurface_status[display_order % SURFACE_NUM] = SRC_SURFACE_IN_ENCODING; pthread_mutex_unlock(&encode_mutex); } static void * storage_task_thread(void *t) { while (1) { struct storage_task_t *current; current = storage_task_dequeue(); if (current == NULL) { pthread_mutex_lock(&encode_mutex); pthread_cond_wait(&encode_cond, &encode_mutex); pthread_mutex_unlock(&encode_mutex); continue; } storage_task(current->display_order, current->encode_order); free(current); /* all frames are saved, exit the thread */ if (++frame_coded >= ips.frame_count) break; } return 0; } static int storage_task_queue(unsigned long long display_order, unsigned long long encode_order) { struct storage_task_t *tmp; tmp = calloc(1, sizeof(struct storage_task_t)); if (tmp) { tmp->display_order = display_order; tmp->encode_order = encode_order; } pthread_mutex_lock(&encode_mutex); if (storage_task_header == NULL) { storage_task_header = tmp; storage_task_tail = tmp; } else { storage_task_tail->next = tmp; storage_task_tail = tmp; } srcsurface_status[display_order % SURFACE_NUM] = SRC_SURFACE_IN_STORAGE; pthread_cond_signal(&encode_cond); pthread_mutex_unlock(&encode_mutex); return 0; } static int encode_frames(void) { unsigned int i, tmp; VAStatus va_status; //VASurfaceStatus surface_status; /* upload RAW YUV data into all surfaces */ tmp = GetTickCount(); if (srcyuv_fp != NULL) { for (i = 0; i < SURFACE_NUM; i++) load_surface(src_surface[i], i); } else upload_source_YUV_once_for_all(); UploadPictureTicks += GetTickCount() - tmp; /* ready for encoding */ memset(srcsurface_status, SRC_SURFACE_IN_ENCODING, sizeof(srcsurface_status)); memset(&seq_param, 0, sizeof(seq_param)); memset(&pic_param, 0, sizeof(pic_param)); memset(&tile_group_param, 0, sizeof(tile_group_param)); if (ips.encode_syncmode == 0) pthread_create(&encode_thread, NULL, storage_task_thread, NULL); for (current_frame_encoding = 0; current_frame_encoding < ips.frame_count; current_frame_encoding++) { encoding2display_order(current_frame_encoding, ips.intra_period, ¤t_frame_display, ¤t_frame_type); printf("%s : %lld %s : %lld type : %d\n", "encoding order", current_frame_encoding, "Display order", current_frame_display, current_frame_type); /* check if the source frame is ready */ while (srcsurface_status[current_slot] != SRC_SURFACE_IN_ENCODING) { usleep(1); } tmp = GetTickCount(); va_status = vaBeginPicture(va_dpy, context_id, src_surface[current_slot]); CHECK_VASTATUS(va_status, "vaBeginPicture"); BeginPictureTicks += GetTickCount() - tmp; tmp = GetTickCount(); //start of render process // prepare parameters used for sequence and frame fill_sps_header(); fill_pps_header(current_frame_display); // init length of packed headers len_ivf_header = 0; len_seq_header = 0; len_pic_header = 0; // render headers // first frame send IVF sequence header + frame header if(current_frame_encoding == 0) { render_ivf_header(); //44 byte, 32byte sequence ivf header, 12 byte frame ivf header len_ivf_header = 44; } else { render_ivf_frame_header(); //12 byte frame ivf header len_ivf_header = 12; } render_TD();//render OBU_TEMPORAL_DELIMITER if (current_frame_type == KEY_FRAME) { if(current_frame_encoding == 0) render_sequence(); //render SPS only needed in first frame len_seq_header = render_packedsequence(); //render packed sequence header } else { len_seq_header = 0; } if((ips.RateControlMethod == 2 || ips.RateControlMethod == 4) && current_frame_encoding == 0) { // misc buffer are not need in CQP case // only needed in first frame render_misc_buffer(); } render_packedpicture(); //render packed frame header render_picture(); //render frame PPS buffer render_tile_group(); //render tile group buffer RenderPictureTicks += GetTickCount() - tmp; tmp = GetTickCount(); va_status = vaEndPicture(va_dpy, context_id); CHECK_VASTATUS(va_status, "vaEndPicture"); EndPictureTicks += GetTickCount() - tmp; if (ips.encode_syncmode) storage_task(current_frame_display, current_frame_encoding); else /* queue the storage task queue */ storage_task_queue(current_frame_display, current_frame_encoding); } if (ips.encode_syncmode == 0) { int ret; pthread_join(encode_thread, (void **)&ret); } return 0; } static int calc_PSNR(double *psnr) { char *srcyuv_ptr = NULL, *recyuv_ptr = NULL, tmp; unsigned long long min_size; unsigned long long i, sse = 0; double ssemean; int fourM = 0x400000; /* 4M */ min_size = MIN(srcyuv_frames, ips.frame_count) * ips.width * ips.height * 1.5; for (i = 0; i < min_size; i++) { unsigned long long j = i % fourM; if ((i % fourM) == 0) { if (srcyuv_ptr) munmap(srcyuv_ptr, fourM); if (recyuv_ptr) munmap(recyuv_ptr, fourM); srcyuv_ptr = mmap(0, fourM, PROT_READ, MAP_SHARED, fileno(srcyuv_fp), i); recyuv_ptr = mmap(0, fourM, PROT_READ, MAP_SHARED, fileno(recyuv_fp), i); if ((srcyuv_ptr == MAP_FAILED) || (recyuv_ptr == MAP_FAILED)) { if (srcyuv_ptr != MAP_FAILED) munmap(srcyuv_ptr, fourM); if (recyuv_ptr != MAP_FAILED) munmap(recyuv_ptr, fourM); printf("Failed to mmap YUV files\n"); return 1; } } tmp = srcyuv_ptr[j] - recyuv_ptr[j]; sse += tmp * tmp; } ssemean = (double)sse / (double)min_size; *psnr = 20.0 * log10(255) - 10.0 * log10(ssemean); if (srcyuv_ptr) munmap(srcyuv_ptr, fourM); if (recyuv_ptr) munmap(recyuv_ptr, fourM); return 0; } static int print_performance(unsigned int PictureCount) { unsigned int psnr_ret = 1, others = 0; double psnr = 0, total_size = ips.width * ips.height * 1.5 * ips.frame_count; if (ips.calc_psnr && srcyuv_fp && recyuv_fp) psnr_ret = calc_PSNR(&psnr); others = TotalTicks - UploadPictureTicks - BeginPictureTicks - RenderPictureTicks - EndPictureTicks - SyncPictureTicks - SavePictureTicks; printf("\n\n"); printf("PERFORMANCE: Frame Rate : %.2f fps (%d frames, %d ms (%.2f ms per frame))\n", (double) 1000 * PictureCount / TotalTicks, PictureCount, TotalTicks, ((double) TotalTicks) / (double) PictureCount); printf("PERFORMANCE: Compression ratio : %d:1\n", (unsigned int)(total_size / frame_size)); if (psnr_ret == 0) printf("PERFORMANCE: PSNR : %.2f (%lld frames calculated)\n", psnr, MIN(ips.frame_count, srcyuv_frames)); printf("PERFORMANCE: UploadPicture : %d ms (%.2f, %.2f%% percent)\n", (int) UploadPictureTicks, ((double) UploadPictureTicks) / (double) PictureCount, UploadPictureTicks / (double) TotalTicks / 0.01); printf("PERFORMANCE: vaBeginPicture : %d ms (%.2f, %.2f%% percent)\n", (int) BeginPictureTicks, ((double) BeginPictureTicks) / (double) PictureCount, BeginPictureTicks / (double) TotalTicks / 0.01); printf("PERFORMANCE: vaRenderHeader : %d ms (%.2f, %.2f%% percent)\n", (int) RenderPictureTicks, ((double) RenderPictureTicks) / (double) PictureCount, RenderPictureTicks / (double) TotalTicks / 0.01); printf("PERFORMANCE: vaEndPicture : %d ms (%.2f, %.2f%% percent)\n", (int) EndPictureTicks, ((double) EndPictureTicks) / (double) PictureCount, EndPictureTicks / (double) TotalTicks / 0.01); printf("PERFORMANCE: vaSyncSurface : %d ms (%.2f, %.2f%% percent)\n", (int) SyncPictureTicks, ((double) SyncPictureTicks) / (double) PictureCount, SyncPictureTicks / (double) TotalTicks / 0.01); printf("PERFORMANCE: SavePicture : %d ms (%.2f, %.2f%% percent)\n", (int) SavePictureTicks, ((double) SavePictureTicks) / (double) PictureCount, SavePictureTicks / (double) TotalTicks / 0.01); printf("PERFORMANCE: Others : %d ms (%.2f, %.2f%% percent)\n", (int) others, ((double) others) / (double) PictureCount, others / (double) TotalTicks / 0.01); if (ips.encode_syncmode == 0) printf("(Multithread enabled, the timing is only for reference)\n"); return 0; } int main(int argc, char **argv) { unsigned int start; process_cmdline(argc, argv); print_input(); start = GetTickCount(); init_va(); setup_encode(); encode_frames(); release_encode(); deinit_va(); //free memory if(ips.output) free(ips.output); if(ips.srcyuv) free(ips.srcyuv); if(ips.recyuv) free(ips.recyuv); TotalTicks += GetTickCount() - start; print_performance(ips.frame_count); return 0; }