diff options
| -rw-r--r-- | test/encode/Makefile.am | 16 | ||||
| -rw-r--r-- | test/encode/svctenc.c | 3104 | ||||
| -rw-r--r-- | va/wayland/wayland-drm-client-protocol.h | 117 |
3 files changed, 3193 insertions, 44 deletions
diff --git a/test/encode/Makefile.am b/test/encode/Makefile.am index d2ac265..9a47c2c 100644 --- a/test/encode/Makefile.am +++ b/test/encode/Makefile.am @@ -21,6 +21,7 @@ # SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. bin_PROGRAMS = avcenc mpeg2vaenc h264encode jpegenc +noinst_PROGRAMS = svctenc AM_CPPFLAGS = \ -Wall \ @@ -54,10 +55,17 @@ jpegenc_CFLAGS = -I$(top_srcdir)/test/common -g jpegenc_LDADD = \ $(top_builddir)/va/libva.la \ $(top_builddir)/test/common/libva-display.la \ - -lpthread - -valgrind: $(bin_PROGRAMS) - for a in $(bin_PROGRAMS); do \ + -lpthread + +svctenc_SOURCES = svctenc.c +svctenc_CFLAGS = -I$(top_srcdir)/test/common -g +svctenc_LDADD = \ + $(top_builddir)/va/libva.la \ + $(top_builddir)/test/common/libva-display.la \ + -lpthread -lm + +valgrind: $(bin_PROGRAMS) $(noinst_PROGRAMS) + for a in $(bin_PROGRAMS) $(noinst_PROGRAMS); do \ valgrind --leak-check=full --show-reachable=yes .libs/$$a; \ done diff --git a/test/encode/svctenc.c b/test/encode/svctenc.c new file mode 100644 index 0000000..f7406c5 --- /dev/null +++ b/test/encode/svctenc.c @@ -0,0 +1,3104 @@ +/* + * Copyright (c) 2016 Intel Corporation. All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the + * "Software"), to deal in the Software without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sub license, and/or sell copies of the Software, and to + * permit persons to whom the Software is furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice (including the + * next paragraph) shall be included in all copies or substantial portions + * of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. + * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR + * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, + * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE + * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +/* + * Simple H.264/AVC temporal scalability encoder based on libVA. + * + */ + +#include "sysdeps.h" +#include <stdio.h> +#include <string.h> +#include <stdlib.h> +#include <getopt.h> +#include <unistd.h> + +#include <sys/time.h> +#include <sys/types.h> +#include <sys/stat.h> +#include <fcntl.h> +#include <assert.h> +#include <time.h> +#include <math.h> + +#include <pthread.h> + +#include <va/va.h> +#include "va_display.h" + +#define SLICE_TYPE_P 0 +#define SLICE_TYPE_B 1 +#define SLICE_TYPE_I 2 + +#define IS_I_SLICE(type) (SLICE_TYPE_I == (type) || SLICE_TYPE_I == (type - 5)) +#define IS_P_SLICE(type) (SLICE_TYPE_P == (type) || SLICE_TYPE_P == (type - 5)) +#define IS_B_SLICE(type) (SLICE_TYPE_B == (type) || SLICE_TYPE_B == (type - 5)) + +#define NAL_REF_IDC_NONE 0 +#define NAL_REF_IDC_LOW 1 +#define NAL_REF_IDC_MEDIUM 2 +#define NAL_REF_IDC_HIGH 3 + +#define NAL_NON_IDR 1 +#define NAL_IDR 5 +#define NAL_SEI 6 +#define NAL_SPS 7 +#define NAL_PPS 8 +#define NAL_PREFIX 14 +#define NAL_SUBSET_SPS 15 + +#define ENTROPY_MODE_CAVLC 0 +#define ENTROPY_MODE_CABAC 1 + +#define PROFILE_IDC_BASELINE 66 +#define PROFILE_IDC_MAIN 77 +#define PROFILE_IDC_SCALABLE_BASELINE 83 +#define PROFILE_IDC_SCALABLE_HIGH 86 +#define PROFILE_IDC_HIGH 100 + +#define SRC_SURFACE_IN_ENCODING 0 +#define SRC_SURFACE_IN_STORAGE 1 + +#define NUM_SURFACES 32 + +#define ARRAY_ELEMS(a) (sizeof(a) / sizeof((a)[0])) + +#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 MAX_SLICES 32 +#define MAX_LAYERS 4 + +#define MIN(a, b) ((a) > (b) ? (b) : (a)) +#define MAX(a, b) ((a) > (b) ? (a) : (b)) + +static VASurfaceID src_surfaces[NUM_SURFACES]; +static VASurfaceID rec_surfaces[NUM_SURFACES]; +static int src_surface_status[NUM_SURFACES]; + +static int temporal_ids_in_bgop[16] = { // index is (encoding order) % gop_size - 1, available from the 2nd encoded frame + 0, /* temporal 0 */ + 1, /* temporal 1 */ + 2, 2, /* temporal 2 */ + 3, 3, 3, 3, /* temporal 3 */ + 4, 4, 4, 4, 4, 4, 4, 4 /* temporal 4 */ +}; + +static int temporal_ids_in_pgop[16] = { // index is (encoding order) % gop_size - 1, available from the 2nd encoded frame + 1, 2, 1, 3, // each element is (the number of temporal layers - temporal id) + 1, 2, 1, 3, + 1, 2, 1, 3, + 1, 2, 1, 3, +}; + +static int gop_factors_in_bgop[16] = { + 1, + 1, + 1, 3, + 1, 3, 5, 7, + 1, 3, 5, 7, 9, 11, 13, 15 +}; + +static float frame_rates[4] = { + 7.5, + 15, + 30, + 60, +}; + +static VAProfile g_va_profiles[] = { + VAProfileH264High, + VAProfileH264Baseline, + VAProfileH264ConstrainedBaseline, +}; + +typedef struct _svcenc_surface +{ + int slot_in_surfaces; /* index in src_surfaces and rec_surfaces */ + int coding_order; + int display_order; + int temporal_id; + int frame_num; + int poc; + unsigned int is_intra : 1; + unsigned int is_idr : 1; + unsigned int is_ref : 1; + VAEncPictureType picture_type; + VASurfaceID rec_surface; +} svcenc_surface; + +static svcenc_surface ref_frames[16], ref_list0[32], ref_list1[32]; + +static pthread_mutex_t upload_mutex = PTHREAD_MUTEX_INITIALIZER; +static pthread_cond_t upload_cond = PTHREAD_COND_INITIALIZER; + +struct upload_task_t { + void *next; + unsigned int display_order; + unsigned int surface; +}; + +struct svcenc_context +{ + /* parameter info */ + FILE *ifp; /* a FILE pointer for source YUV file */ + FILE *ofp; /* a FILE pointer for output SVC file */ + int width; + int height; + int frame_size; + int num_pictures; + int num_slices; + int qp; /* quantisation parameter, default value is 26 */ + unsigned char *frame_data_buffer; /* buffer for input surface, the length is the maximum frame_size */ + int gop_size; + int max_num_ref_frames; + int num_ref_frames; + int hierarchical_levels; + int layer_brc; + + /* the info for next picture in encoding order */ + svcenc_surface next_svcenc_surface; + + /* GOP info */ + int intra_idr_period; + int intra_period; + int ip_period; + int num_remainder_bframes; + int gop_type; /* 0: p hierarchical, 1: B hierarchical, default is 0 */ + + /* bitrate info */ + int rate_control_mode; + int bits_per_kbps; + int framerate_per_100s; + int i_initial_cpb_removal_delay; + int i_initial_cpb_removal_delay_offset; + int i_initial_cpb_removal_delay_length; + int i_cpb_removal_delay; + int i_cpb_removal_delay_length; + int i_dpb_output_delay_length; + int time_offset_length; + + unsigned long long idr_frame_num; + unsigned long long prev_idr_cpb_removal; + unsigned long long current_idr_cpb_removal; + unsigned long long current_cpb_removal; + + /* This is relative to the current_cpb_removal */ + unsigned int current_dpb_removal_delta; + + int profile_idc; + int constraint_set_flag; + + int svc_profile_idc; + int svc_constraint_set_flag; + + /* reordering info for l0/l1, + * bit0-3: ref_pic_list_modification_flag_lX (X=0,1), + * bit4-7: modification_of_pic_nums_idc, + * bit8-15: abs_diff_pic_num_minus1 + * bit16-23: num_ref_idx_active_override_flag + * bit24-31: num_ref_idx_lX_active_minus1 (X=0,1), + */ + unsigned int reordering_info[2]; + + /* VA info */ + VADisplay va_dpy; + VAProfile profile; + VAEncSequenceParameterBufferH264 seq_param; + VAEncPictureParameterBufferH264 pic_param; + VAEncSliceParameterBufferH264 slice_param[MAX_SLICES]; + VAContextID context_id; + VAConfigID config_id; + VABufferID seq_param_buf_id; /* Sequence level parameter */ + VABufferID pic_param_buf_id; /* Picture level parameter */ + VABufferID slice_param_buf_id[MAX_SLICES]; /* Slice level parameter, multil slices */ + VABufferID codedbuf_buf_id; /* Output buffer, compressed data */ + VABufferID packed_sei_scalability_info_header_param_buf_id; + VABufferID packed_sei_scalability_info_buf_id; + VABufferID packed_seq_header_param_buf_id; + VABufferID packed_seq_buf_id; + VABufferID packed_svc_seq_header_param_buf_id; + VABufferID packed_svc_seq_buf_id; + VABufferID packed_pic_header_param_buf_id; + VABufferID packed_pic_buf_id; + VABufferID packed_sei_header_param_buf_id; /* the SEI buffer */ + VABufferID packed_sei_buf_id; + VABufferID misc_parameter_layer_structure_buf_id; + VABufferID misc_parameter_ratecontrol_buf_id[MAX_LAYERS]; + VABufferID misc_parameter_framerate_buf_id[MAX_LAYERS]; + VABufferID misc_parameter_hrd_buf_id; + VABufferID packed_slice_header_param_buf_id[MAX_SLICES]; + VABufferID packed_slice_header_data_buf_id[MAX_SLICES]; + VABufferID packed_prefix_nal_unit_param_buf_id[MAX_SLICES]; + VABufferID packed_prefix_nal_unit_data_buf_id[MAX_SLICES]; + + /* thread info */ + pthread_t upload_thread; + struct upload_task_t *upload_task_header; + struct upload_task_t *upload_task_tail; +}; + +/* bitstream */ +#define BITSTREAM_ALLOCATE_STEPPING 4096 + +struct __bitstream { + unsigned int *buffer; + int bit_offset; + int max_size_in_dword; +}; + +typedef struct __bitstream bitstream; + +static unsigned int +va_swap32(unsigned int val) +{ + unsigned char *pval = (unsigned char *)&val; + + return ((pval[0] << 24) | + (pval[1] << 16) | + (pval[2] << 8) | + (pval[3] << 0)); +} + +static void +bitstream_start(bitstream *bs) +{ + bs->max_size_in_dword = BITSTREAM_ALLOCATE_STEPPING; + bs->buffer = calloc(bs->max_size_in_dword * sizeof(int), 1); + bs->bit_offset = 0; +} + +static void +bitstream_end(bitstream *bs) +{ + int pos = (bs->bit_offset >> 5); + int bit_offset = (bs->bit_offset & 0x1f); + int bit_left = 32 - bit_offset; + + if (bit_offset) { + bs->buffer[pos] = va_swap32((bs->buffer[pos] << bit_left)); + } +} + +static void +bitstream_put_ui(bitstream *bs, unsigned int val, int size_in_bits) +{ + int pos = (bs->bit_offset >> 5); + int bit_offset = (bs->bit_offset & 0x1f); + int bit_left = 32 - bit_offset; + + if (!size_in_bits) + return; + + bs->bit_offset += size_in_bits; + + if (bit_left > size_in_bits) { + bs->buffer[pos] = (bs->buffer[pos] << size_in_bits | val); + } else { + size_in_bits -= bit_left; + bs->buffer[pos] = (bs->buffer[pos] << bit_left) | (val >> size_in_bits); + bs->buffer[pos] = va_swap32(bs->buffer[pos]); + + if (pos + 1 == bs->max_size_in_dword) { + bs->max_size_in_dword += BITSTREAM_ALLOCATE_STEPPING; + bs->buffer = realloc(bs->buffer, bs->max_size_in_dword * sizeof(unsigned int)); + } + + bs->buffer[pos + 1] = val; + } +} + +static void +bitstream_put_ue(bitstream *bs, unsigned int val) +{ + int size_in_bits = 0; + int tmp_val = ++val; + + while (tmp_val) { + tmp_val >>= 1; + size_in_bits++; + } + + bitstream_put_ui(bs, 0, size_in_bits - 1); // leading zero + bitstream_put_ui(bs, val, size_in_bits); +} + +static void +bitstream_put_se(bitstream *bs, int val) +{ + unsigned int new_val; + + if (val <= 0) + new_val = -2 * val; + else + new_val = 2 * val - 1; + + bitstream_put_ue(bs, new_val); +} + +static void +bitstream_byte_aligning(bitstream *bs, int bit) +{ + int bit_offset = (bs->bit_offset & 0x7); + int bit_left = 8 - bit_offset; + int new_val; + + if (!bit_offset) + return; + + assert(bit == 0 || bit == 1); + + if (bit) + new_val = (1 << bit_left) - 1; + else + new_val = 0; + + bitstream_put_ui(bs, new_val, bit_left); +} + +static void +rbsp_trailing_bits(bitstream *bs) +{ + bitstream_put_ui(bs, 1, 1); + bitstream_byte_aligning(bs, 0); +} + +static void +nal_start_code_prefix(bitstream *bs) +{ + bitstream_put_ui(bs, 0x00000001, 32); +} + +static void +nal_header(bitstream *bs, int nal_ref_idc, int nal_unit_type) +{ + bitstream_put_ui(bs, 0, 1); /* forbidden_zero_bit: 0 */ + bitstream_put_ui(bs, nal_ref_idc, 2); + bitstream_put_ui(bs, nal_unit_type, 5); +} + +static void +sps_data(struct svcenc_context *ctx, + const VAEncSequenceParameterBufferH264 *seq_param, + bitstream *bs) +{ + bitstream_put_ui(bs, ctx->profile_idc, 8); /* profile_idc */ + bitstream_put_ui(bs, !!(ctx->constraint_set_flag & 1), 1); /* constraint_set0_flag */ + bitstream_put_ui(bs, !!(ctx->constraint_set_flag & 2), 1); /* constraint_set1_flag */ + bitstream_put_ui(bs, !!(ctx->constraint_set_flag & 4), 1); /* constraint_set2_flag */ + bitstream_put_ui(bs, !!(ctx->constraint_set_flag & 8), 1); /* constraint_set3_flag */ + bitstream_put_ui(bs, !!(ctx->constraint_set_flag & 16), 1); /* constraint_set4_flag */ + bitstream_put_ui(bs, !!(ctx->constraint_set_flag & 32), 1); /* constraint_set5_flag */ + bitstream_put_ui(bs, 0, 2); /* reserved_zero_2bits */ + bitstream_put_ui(bs, seq_param->level_idc, 8); /* level_idc */ + bitstream_put_ue(bs, seq_param->seq_parameter_set_id); /* seq_parameter_set_id */ + + if (ctx->profile_idc == PROFILE_IDC_HIGH || + ctx->profile_idc == PROFILE_IDC_SCALABLE_HIGH || + ctx->profile_idc == PROFILE_IDC_SCALABLE_BASELINE) { + bitstream_put_ue(bs, 1); /* chroma_format_idc = 1, 4:2:0 */ + bitstream_put_ue(bs, 0); /* bit_depth_luma_minus8 */ + bitstream_put_ue(bs, 0); /* bit_depth_chroma_minus8 */ + bitstream_put_ui(bs, 0, 1); /* qpprime_y_zero_transform_bypass_flag */ + bitstream_put_ui(bs, 0, 1); /* seq_scaling_matrix_present_flag */ + } + + bitstream_put_ue(bs, seq_param->seq_fields.bits.log2_max_frame_num_minus4); /* log2_max_frame_num_minus4 */ + bitstream_put_ue(bs, seq_param->seq_fields.bits.pic_order_cnt_type); /* pic_order_cnt_type */ + + if (seq_param->seq_fields.bits.pic_order_cnt_type == 0) + bitstream_put_ue(bs, seq_param->seq_fields.bits.log2_max_pic_order_cnt_lsb_minus4); /* log2_max_pic_order_cnt_lsb_minus4 */ + else { + assert(0); + } + + bitstream_put_ue(bs, seq_param->max_num_ref_frames); /* num_ref_frames */ + bitstream_put_ui(bs, 0, 1); /* gaps_in_frame_num_value_allowed_flag */ + + bitstream_put_ue(bs, seq_param->picture_width_in_mbs - 1); /* pic_width_in_mbs_minus1 */ + bitstream_put_ue(bs, seq_param->picture_height_in_mbs - 1); /* pic_height_in_map_units_minus1 */ + bitstream_put_ui(bs, seq_param->seq_fields.bits.frame_mbs_only_flag, 1); /* frame_mbs_only_flag */ + + if (!seq_param->seq_fields.bits.frame_mbs_only_flag) { + assert(0); + } + + bitstream_put_ui(bs, seq_param->seq_fields.bits.direct_8x8_inference_flag, 1); /* direct_8x8_inference_flag */ + bitstream_put_ui(bs, seq_param->frame_cropping_flag, 1); /* frame_cropping_flag */ + + if (seq_param->frame_cropping_flag) { + bitstream_put_ue(bs, seq_param->frame_crop_left_offset); /* frame_crop_left_offset */ + bitstream_put_ue(bs, seq_param->frame_crop_right_offset); /* frame_crop_right_offset */ + bitstream_put_ue(bs, seq_param->frame_crop_top_offset); /* frame_crop_top_offset */ + bitstream_put_ue(bs, seq_param->frame_crop_bottom_offset); /* frame_crop_bottom_offset */ + } + + if (ctx->bits_per_kbps < 0) { + bitstream_put_ui(bs, 0, 1); /* vui_parameters_present_flag */ + } else { + bitstream_put_ui(bs, 1, 1); /* vui_parameters_present_flag */ + bitstream_put_ui(bs, 0, 1); /* aspect_ratio_info_present_flag */ + bitstream_put_ui(bs, 0, 1); /* overscan_info_present_flag */ + bitstream_put_ui(bs, 0, 1); /* video_signal_type_present_flag */ + bitstream_put_ui(bs, 0, 1); /* chroma_loc_info_present_flag */ + bitstream_put_ui(bs, 1, 1); /* timing_info_present_flag */ + { + bitstream_put_ui(bs, seq_param->num_units_in_tick, 32); + bitstream_put_ui(bs, seq_param->time_scale, 32); + bitstream_put_ui(bs, 1, 1); + } + bitstream_put_ui(bs, 1, 1); /* nal_hrd_parameters_present_flag */ + { + // hrd_parameters + bitstream_put_ue(bs, 0); /* cpb_cnt_minus1 */ + bitstream_put_ui(bs, 0, 4); /* bit_rate_scale */ + bitstream_put_ui(bs, 2, 4); /* cpb_size_scale */ + + /* the bits_per_kbps is in kbps */ + bitstream_put_ue(bs, (((ctx->bits_per_kbps * 1024) >> 6) - 1)); /* bit_rate_value_minus1[0] */ + bitstream_put_ue(bs, ((ctx->bits_per_kbps * 8 * 1024) >> 6) - 1); /* cpb_size_value_minus1[0] */ + bitstream_put_ui(bs, 1, 1); /* cbr_flag[0] */ + + /* initial_cpb_removal_delay_length_minus1 */ + bitstream_put_ui(bs, (ctx->i_initial_cpb_removal_delay_length - 1), 5); + /* cpb_removal_delay_length_minus1 */ + bitstream_put_ui(bs, (ctx->i_cpb_removal_delay_length - 1), 5); + /* dpb_output_delay_length_minus1 */ + bitstream_put_ui(bs, (ctx->i_dpb_output_delay_length - 1), 5); + /* time_offset_length */ + bitstream_put_ui(bs, (ctx->time_offset_length - 1), 5); + } + + bitstream_put_ui(bs, 0, 1); /* vcl_hrd_parameters_present_flag */ + bitstream_put_ui(bs, 0, 1); /* low_delay_hrd_flag */ + + bitstream_put_ui(bs, 0, 1); /* pic_struct_present_flag */ + bitstream_put_ui(bs, 0, 1); /* bitstream_restriction_flag */ + } +} + +static void +sps_svc_extension(struct svcenc_context *ctx, + const VAEncSequenceParameterBufferH264 *sps_param, + bitstream *bs) +{ + bitstream_put_ui(bs, 0, 1); /* inter_layer_deblocking_filter_control_present_flag */ + bitstream_put_ui(bs, 0, 2); /* extended_spatial_scalability_idc */ + + /* if (ChromaArrayType == 1) */ + bitstream_put_ui(bs, 0, 1); /* chroma_phase_x_plus1_flag */ + bitstream_put_ui(bs, 1, 2); /* chroma_phase_y_plus1 */ + +#if 0 + if (extended_spatial_scalability_idc == 1) { + /* if (ChromaArrayType > 0) */ + bitstream_put_ui(bs, 0, 1); /* seq_ref_layer_chroma_phase_x_plus1_flag */ + bitstream_put_ui(bs, 0, 2); /* seq_ref_layer_chroma_phase_y_plus1 */ + + bitstream_put_se(bs, 0); /* seq_scaled_ref_layer_left_offset */ + bitstream_put_se(bs, 0); /* seq_scaled_ref_layer_top_offset */ + bitstream_put_se(bs, 0); /* seq_scaled_ref_layer_right_offset */ + bitstream_put_se(bs, 0); /* seq_scaled_ref_layer_bottom_offset */ + } +#endif + + bitstream_put_ui(bs, 0, 1); /* seq_tcoeff_level_prediction_flag */ + +#if 0 + if (seq_tcoeff_level_prediction_flag) + bitstream_put_ui(bs, 0, 1); /* adaptive_tcoeff_level_prediction_flag */ +#endif + + bitstream_put_ui(bs, 0, 1); /* slice_header_restriction_flag */ +} + +static void +sps_svc_vui_parameters_extension(struct svcenc_context *ctx, + const VAEncSequenceParameterBufferH264 *sps_param, + bitstream *bs) +{ + bitstream_put_ui(bs, 0, 1); /* svc_vui_parameters_present_flag */ +} + +static void +sps_additional_extension2(struct svcenc_context *ctx, + const VAEncSequenceParameterBufferH264 *sps_param, + bitstream *bs) +{ + bitstream_put_ui(bs, 0, 1); /* additional_extension2_flag */ +} + +static void +pps_rbsp(struct svcenc_context *ctx, + const VAEncPictureParameterBufferH264 *pic_param, + bitstream *bs) +{ + bitstream_put_ue(bs, pic_param->pic_parameter_set_id); /* pic_parameter_set_id */ + bitstream_put_ue(bs, pic_param->seq_parameter_set_id); /* seq_parameter_set_id */ + + bitstream_put_ui(bs, pic_param->pic_fields.bits.entropy_coding_mode_flag, 1); /* entropy_coding_mode_flag */ + + bitstream_put_ui(bs, 0, 1); /* pic_order_present_flag: 0 */ + + bitstream_put_ue(bs, 0); /* num_slice_groups_minus1 */ + + bitstream_put_ue(bs, pic_param->num_ref_idx_l0_active_minus1); /* num_ref_idx_l0_active_minus1 */ + bitstream_put_ue(bs, pic_param->num_ref_idx_l1_active_minus1); /* num_ref_idx_l1_active_minus1 1 */ + + bitstream_put_ui(bs, pic_param->pic_fields.bits.weighted_pred_flag, 1); /* weighted_pred_flag: 0 */ + bitstream_put_ui(bs, pic_param->pic_fields.bits.weighted_bipred_idc, 2); /* weighted_bipred_idc: 0 */ + + bitstream_put_se(bs, pic_param->pic_init_qp - 26); /* pic_init_qp_minus26 */ + bitstream_put_se(bs, 0); /* pic_init_qs_minus26 */ + bitstream_put_se(bs, 0); /* chroma_qp_index_offset */ + + bitstream_put_ui(bs, pic_param->pic_fields.bits.deblocking_filter_control_present_flag, 1); /* deblocking_filter_control_present_flag */ + bitstream_put_ui(bs, 0, 1); /* constrained_intra_pred_flag */ + bitstream_put_ui(bs, 0, 1); /* redundant_pic_cnt_present_flag */ + + /* more_rbsp_data */ + bitstream_put_ui(bs, pic_param->pic_fields.bits.transform_8x8_mode_flag, 1); /*transform_8x8_mode_flag */ + bitstream_put_ui(bs, 0, 1); /* pic_scaling_matrix_present_flag */ + bitstream_put_se(bs, pic_param->second_chroma_qp_index_offset ); /*second_chroma_qp_index_offset */ + + rbsp_trailing_bits(bs); +} + +static int +build_packed_seq_buffer(struct svcenc_context *ctx, + const VAEncSequenceParameterBufferH264 *seq_param, + unsigned char **header_buffer) +{ + bitstream bs; + + bitstream_start(&bs); + + nal_start_code_prefix(&bs); + nal_header(&bs, NAL_REF_IDC_HIGH, NAL_SPS); + + sps_data(ctx, seq_param, &bs); + rbsp_trailing_bits(&bs); /* rbsp_trailing_bits */ + + bitstream_end(&bs); + + *header_buffer = (unsigned char *)bs.buffer; + return bs.bit_offset; +} + +static int +build_packed_subset_seq_buffer(struct svcenc_context *ctx, + const VAEncSequenceParameterBufferH264 *seq_param, + unsigned char **header_buffer) +{ + bitstream bs; + + bitstream_start(&bs); + + nal_start_code_prefix(&bs); + nal_header(&bs, NAL_REF_IDC_HIGH, NAL_SUBSET_SPS); + + sps_data(ctx, seq_param, &bs); + sps_svc_extension(ctx, seq_param, &bs); + sps_svc_vui_parameters_extension(ctx, seq_param, &bs); + sps_additional_extension2(ctx, seq_param, &bs); + rbsp_trailing_bits(&bs); /* rbsp_trailing_bits */ + + bitstream_end(&bs); + + *header_buffer = (unsigned char *)bs.buffer; + return bs.bit_offset; +} + +static int +build_packed_pic_buffer(struct svcenc_context *ctx, + const VAEncPictureParameterBufferH264 *pic_param, + unsigned char **header_buffer) +{ + bitstream bs; + + bitstream_start(&bs); + nal_start_code_prefix(&bs); + nal_header(&bs, NAL_REF_IDC_HIGH, NAL_PPS); + pps_rbsp(ctx, pic_param, &bs); + bitstream_end(&bs); + + *header_buffer = (unsigned char *)bs.buffer; + return bs.bit_offset; +} + +static int +build_packed_sei_buffering_period_buffer(struct svcenc_context *ctx, + const VAEncSequenceParameterBufferH264 *seq_param, + int frame_num, + unsigned char **sei_buffer) +{ + bitstream sei_bp_bs; + + if (ctx->rate_control_mode & VA_RC_CQP || + frame_num) { + *sei_buffer = NULL; + return 0; + } + + bitstream_start(&sei_bp_bs); + bitstream_put_ue(&sei_bp_bs, seq_param->seq_parameter_set_id); /* seq_parameter_set_id */ + /* SEI buffer period info */ + /* NALHrdBpPresentFlag == 1 */ + bitstream_put_ui(&sei_bp_bs, ctx->i_initial_cpb_removal_delay, ctx->i_initial_cpb_removal_delay_length); + bitstream_put_ui(&sei_bp_bs, ctx->i_initial_cpb_removal_delay_offset, ctx->i_initial_cpb_removal_delay_length); + + if (sei_bp_bs.bit_offset & 0x7) { + bitstream_put_ui(&sei_bp_bs, 1, 1); + } + + bitstream_end(&sei_bp_bs); + + *sei_buffer = (unsigned char *)sei_bp_bs.buffer; + + return (sei_bp_bs.bit_offset + 7) / 8; +} + +static int +build_packed_sei_pic_timing_buffer(struct svcenc_context *ctx, int frame_num, unsigned char **sei_buffer) +{ + bitstream sei_pic_bs; + unsigned int cpb_removal_delay; + + if (ctx->rate_control_mode & VA_RC_CQP) { + *sei_buffer = 0; + return 0; + } + + /* SEI pic timing info */ + bitstream_start(&sei_pic_bs); + + /* The info of CPB and DPB delay is controlled by CpbDpbDelaysPresentFlag, + * which is derived as 1 if one of the following conditions is true: + * nal_hrd_parameters_present_flag is present in the bitstream and is equal to 1, + * vcl_hrd_parameters_present_flag is present in the bitstream and is equal to 1, + */ + cpb_removal_delay = (ctx->current_cpb_removal - ctx->prev_idr_cpb_removal); + bitstream_put_ui(&sei_pic_bs, cpb_removal_delay, ctx->i_cpb_removal_delay_length); + bitstream_put_ui(&sei_pic_bs, ctx->current_dpb_removal_delta, ctx->i_dpb_output_delay_length); + + if (sei_pic_bs.bit_offset & 0x7) { + bitstream_put_ui(&sei_pic_bs, 1, 1); + } + + /* The pic_structure_present_flag determines whether the pic_structure + * info is written into the SEI pic timing info. + * Currently it is set to zero. + */ + bitstream_end(&sei_pic_bs); + + *sei_buffer = (unsigned char *)sei_pic_bs.buffer; + + return (sei_pic_bs.bit_offset + 7) / 8; +} + +static int +build_packed_sei_scalability_info_buffer(struct svcenc_context *ctx, + const VAEncSequenceParameterBufferH264 *seq_param, + const VAEncPictureParameterBufferH264 *pic_param, + int frame_num, + unsigned char **sei_buffer) +{ + bitstream scalability_info_bs; + int i; + + if (frame_num) { // non IDR + *sei_buffer = NULL; + return 0; + } + + /* Write scalability_info */ + bitstream_start(&scalability_info_bs); + + bitstream_put_ui(&scalability_info_bs, 0, 1); // temporal_id_nesting_flag: false + bitstream_put_ui(&scalability_info_bs, 0, 1); // priority_layer_info_present_flag: false + bitstream_put_ui(&scalability_info_bs, 0, 1); // priority_id_setting_flag: false + bitstream_put_ue(&scalability_info_bs, ctx->hierarchical_levels - 1); // num_layers_minus1 + + for (i = 0; i < ctx->hierarchical_levels; i++) { + bitstream_put_ue(&scalability_info_bs, i); // layer_id[i] + bitstream_put_ui(&scalability_info_bs, 0, 6); // priority_id[i[ + bitstream_put_ui(&scalability_info_bs, 0, 1); // discardable_flag[i] + bitstream_put_ui(&scalability_info_bs, 0, 3); // dependency_id[i] + bitstream_put_ui(&scalability_info_bs, 0, 4); // quality_id[i] + bitstream_put_ui(&scalability_info_bs, i, 3); // temporal_id[i] + bitstream_put_ui(&scalability_info_bs, 0, 1); // sub_pic_layer_flag[i] + bitstream_put_ui(&scalability_info_bs, 0, 1); // sub_region_layer_flag[i] + bitstream_put_ui(&scalability_info_bs, 0, 1); // iroi_division_info_present_flag[i] + bitstream_put_ui(&scalability_info_bs, 0, 1); // profile_level_info_present_flag[i] + bitstream_put_ui(&scalability_info_bs, 0, 1); // bitrate_info_present_flag[i] + bitstream_put_ui(&scalability_info_bs, 1, 1); // frm_rate_info_present_flag[i] + bitstream_put_ui(&scalability_info_bs, 1, 1); // frm_size_info_present_flag[i] + bitstream_put_ui(&scalability_info_bs, 0, 1); // layer_dependency_info_present_flag[i] + bitstream_put_ui(&scalability_info_bs, 0, 1); // parameter_sets_info_present_flag[i] + bitstream_put_ui(&scalability_info_bs, 0, 1); // bitstream_restriction_info_present_flag[i] + bitstream_put_ui(&scalability_info_bs, 0, 1); // exact_interlayer_pred_flag[i] + bitstream_put_ui(&scalability_info_bs, 0, 1); // layer_conversion_flag[i] + bitstream_put_ui(&scalability_info_bs, 0, 1); // layer_output_flag[i] + + bitstream_put_ui(&scalability_info_bs, 0, 2); // constant_frm_bitrate_idc[i] + bitstream_put_ui(&scalability_info_bs, (int)floor(frame_rates[i] * 256 + 0.5), 16); // avg_frm_rate + + bitstream_put_ue(&scalability_info_bs, seq_param->picture_width_in_mbs - 1); // frm_width_in_mbs_minus1 + bitstream_put_ue(&scalability_info_bs, seq_param->picture_height_in_mbs - 1); // frm_height_in_mbs_minus1 + + bitstream_put_ue(&scalability_info_bs, 0); // layer_dependency_info_src_layer_id_delta[i] + bitstream_put_ue(&scalability_info_bs, 0); // parameter_sets_info_src_layer_id_delta[i] + } + + rbsp_trailing_bits(&scalability_info_bs); + bitstream_end(&scalability_info_bs); + + *sei_buffer = (unsigned char *)scalability_info_bs.buffer; + + return (scalability_info_bs.bit_offset + 7) / 8; +} + +static void +svcenc_update_sei_info(struct svcenc_context *ctx, svcenc_surface *current_surface) +{ + unsigned long long frame_interval; + + if (!(ctx->rate_control_mode & VA_RC_CBR)) { + return; + } + + frame_interval = current_surface->coding_order - ctx->idr_frame_num; + + if (current_surface->is_idr) { + ctx->current_cpb_removal = ctx->prev_idr_cpb_removal + frame_interval * 2; + ctx->idr_frame_num = current_surface->coding_order; + ctx->current_idr_cpb_removal = ctx->current_cpb_removal; + + if (ctx->ip_period) + ctx->current_dpb_removal_delta = (ctx->ip_period + 1) * 2; + else + ctx->current_dpb_removal_delta = 2; + } else { + ctx->current_cpb_removal = ctx->current_idr_cpb_removal + frame_interval * 2; + + if (current_surface->picture_type == VAEncPictureTypeIntra || + current_surface->picture_type == VAEncPictureTypePredictive) { + if (ctx->ip_period) + ctx->current_dpb_removal_delta = (ctx->ip_period + 1) * 2; + else + ctx->current_dpb_removal_delta = 2; + } else + ctx->current_dpb_removal_delta = 2; + } +} + +static int +build_packed_sei_buffer(struct svcenc_context *ctx, + const VAEncSequenceParameterBufferH264 *seq_param, + const VAEncPictureParameterBufferH264 *pic_param, + svcenc_surface *current_surface, + unsigned char **sei_buffer) +{ + unsigned char *scalability_info_buffer = NULL, *buffering_period_buffer = NULL, *pic_timing_buffer = NULL; + int scalability_info_size = 0, buffering_period_size = 0, pic_timing_size = 0; + bitstream nal_bs; + int i; + + svcenc_update_sei_info(ctx, current_surface); + + buffering_period_size = build_packed_sei_buffering_period_buffer(ctx, seq_param, current_surface->frame_num, &buffering_period_buffer); + pic_timing_size = build_packed_sei_pic_timing_buffer(ctx, current_surface->frame_num, &pic_timing_buffer); + scalability_info_size = build_packed_sei_scalability_info_buffer(ctx, seq_param, pic_param, current_surface->frame_num, &scalability_info_buffer); + + if (!buffering_period_buffer && + !pic_timing_buffer && + !scalability_info_buffer) { + *sei_buffer = NULL; + return 0; + } + + bitstream_start(&nal_bs); + nal_start_code_prefix(&nal_bs); + nal_header(&nal_bs, NAL_REF_IDC_NONE, NAL_SEI); + + /* Write the SEI buffer */ + if (buffering_period_buffer) { + assert(buffering_period_size); + + bitstream_put_ui(&nal_bs, 0, 8); // last_payload_type_byte: 0 + bitstream_put_ui(&nal_bs, buffering_period_size, 8); // last_payload_size_byte + + for (i = 0; i < buffering_period_size; i++) { + bitstream_put_ui(&nal_bs, buffering_period_buffer[i], 8); + } + + free(buffering_period_buffer); + } + + if (pic_timing_buffer) { + assert(pic_timing_size); + + bitstream_put_ui(&nal_bs, 1, 8); // last_payload_type_byte: 1 + bitstream_put_ui(&nal_bs, pic_timing_size, 8); // last_payload_size_byte + + for (i = 0; i < pic_timing_size; i++) { + bitstream_put_ui(&nal_bs, pic_timing_buffer[i], 8); + } + + free(pic_timing_buffer); + } + + if (scalability_info_buffer) { + assert(scalability_info_size); + + bitstream_put_ui(&nal_bs, 24, 8); // last_payload_type_byte: 24 + bitstream_put_ui(&nal_bs, scalability_info_size, 8); // last_payload_size_byte + + for (i = 0; i < scalability_info_size; i++) { + bitstream_put_ui(&nal_bs, scalability_info_buffer[i], 8); + } + + free(scalability_info_buffer); + } + + rbsp_trailing_bits(&nal_bs); + bitstream_end(&nal_bs); + + *sei_buffer = (unsigned char *)nal_bs.buffer; + + return nal_bs.bit_offset; +} + +static void +slice_header(bitstream *bs, + VAEncSequenceParameterBufferH264 *sps_param, + VAEncPictureParameterBufferH264 *pic_param, + VAEncSliceParameterBufferH264 *slice_param, + unsigned int reordering_info[2]) +{ + int first_mb_in_slice = slice_param->macroblock_address; + int i; + + bitstream_put_ue(bs, first_mb_in_slice); /* first_mb_in_slice: 0 */ + bitstream_put_ue(bs, slice_param->slice_type); /* slice_type */ + bitstream_put_ue(bs, slice_param->pic_parameter_set_id); /* pic_parameter_set_id: 0 */ + bitstream_put_ui(bs, pic_param->frame_num, sps_param->seq_fields.bits.log2_max_frame_num_minus4 + 4); /* frame_num */ + + /* frame_mbs_only_flag == 1 */ + if (!sps_param->seq_fields.bits.frame_mbs_only_flag) { + /* FIXME: */ + assert(0); + } + + if (pic_param->pic_fields.bits.idr_pic_flag) + bitstream_put_ue(bs, slice_param->idr_pic_id); /* idr_pic_id: 0 */ + + if (sps_param->seq_fields.bits.pic_order_cnt_type == 0) { + bitstream_put_ui(bs, pic_param->CurrPic.TopFieldOrderCnt, sps_param->seq_fields.bits.log2_max_pic_order_cnt_lsb_minus4 + 4); + /* pic_order_present_flag == 0 */ + } else { + /* FIXME: */ + assert(0); + } + + /* redundant_pic_cnt_present_flag == 0 */ + /* slice type */ + if (IS_P_SLICE(slice_param->slice_type)) { + bitstream_put_ui(bs, !!((reordering_info[0] >> 16) & 0xFF), 1); /* num_ref_idx_active_override_flag: */ + + if ((reordering_info[0] >> 16) & 0xFF) + bitstream_put_ue(bs, (reordering_info[0] >> 24) & 0xFF); /* num_ref_idx_l0_active_minus1 */ + + /* ref_pic_list_reordering */ + if (!reordering_info || !(reordering_info[0] & 0x0F)) + bitstream_put_ui(bs, 0, 1); /* ref_pic_list_reordering_flag_l0: 0 */ + else { + bitstream_put_ui(bs, 1, 1); /* ref_pic_list_reordering_flag_l0: 1 */ + bitstream_put_ue(bs, (reordering_info[0] >> 4) & 0x0F); + bitstream_put_ue(bs, (reordering_info[0] >> 8) & 0xFF); + bitstream_put_ue(bs, 3); /* modification_of_pic_nums_idc: 3 */ + } + } else if (IS_B_SLICE(slice_param->slice_type)) { + bitstream_put_ui(bs, slice_param->direct_spatial_mv_pred_flag, 1); /* direct_spatial_mv_pred: 1 */ + + bitstream_put_ui(bs, ((reordering_info[0] >> 16) & 0xFF) || ((reordering_info[1] >> 16) & 0xFF) , 1); /* num_ref_idx_active_override_flag: */ + + if (((reordering_info[0] >> 16) & 0xFF) || ((reordering_info[1] >> 16) & 0xFF)) { + bitstream_put_ue(bs, (reordering_info[0] >> 24) & 0xFF); /* num_ref_idx_l0_active_minus1 */ + bitstream_put_ue(bs, (reordering_info[1] >> 24) & 0xFF); /* num_ref_idx_l0_active_minus1 */ + } + + /* ref_pic_list_reordering */ + + for (i = 0; i < 2; i++) { + if (!reordering_info || !(reordering_info[i] & 0x0F)) + bitstream_put_ui(bs, 0, 1); /* ref_pic_list_reordering_flag_l0/l1: 0 */ + else { + bitstream_put_ui(bs, 1, 1); /* ref_pic_list_reordering_flag_l0/l1: 1 */ + bitstream_put_ue(bs, (reordering_info[i] >> 4) & 0x0F); + bitstream_put_ue(bs, (reordering_info[i] >> 8) & 0xFF); + bitstream_put_ue(bs, 3); /* modification_of_pic_nums_idc: 3 */ + } + } + } + + if ((pic_param->pic_fields.bits.weighted_pred_flag && + IS_P_SLICE(slice_param->slice_type)) || + ((pic_param->pic_fields.bits.weighted_bipred_idc == 1) && + IS_B_SLICE(slice_param->slice_type))) { + /* FIXME: fill weight/offset table */ + assert(0); + } + + /* dec_ref_pic_marking */ + if (pic_param->pic_fields.bits.reference_pic_flag) { /* nal_ref_idc != 0 */ + unsigned char no_output_of_prior_pics_flag = 0; + unsigned char long_term_reference_flag = 0; + unsigned char adaptive_ref_pic_marking_mode_flag = 0; + + if (pic_param->pic_fields.bits.idr_pic_flag) { + bitstream_put_ui(bs, no_output_of_prior_pics_flag, 1); /* no_output_of_prior_pics_flag: 0 */ + bitstream_put_ui(bs, long_term_reference_flag, 1); /* long_term_reference_flag: 0 */ + } else { + bitstream_put_ui(bs, adaptive_ref_pic_marking_mode_flag, 1); /* adaptive_ref_pic_marking_mode_flag: 0 */ + } + } + + if (pic_param->pic_fields.bits.entropy_coding_mode_flag && + !IS_I_SLICE(slice_param->slice_type)) + bitstream_put_ue(bs, slice_param->cabac_init_idc); /* cabac_init_idc: 0 */ + + bitstream_put_se(bs, slice_param->slice_qp_delta); /* slice_qp_delta: 0 */ + + /* ignore for SP/SI */ + + if (pic_param->pic_fields.bits.deblocking_filter_control_present_flag) { + bitstream_put_ue(bs, slice_param->disable_deblocking_filter_idc); /* disable_deblocking_filter_idc: 0 */ + + if (slice_param->disable_deblocking_filter_idc != 1) { + bitstream_put_se(bs, slice_param->slice_alpha_c0_offset_div2); /* slice_alpha_c0_offset_div2: 2 */ + bitstream_put_se(bs, slice_param->slice_beta_offset_div2); /* slice_beta_offset_div2: 2 */ + } + } + + if (pic_param->pic_fields.bits.entropy_coding_mode_flag) { + bitstream_byte_aligning(bs, 1); + } +} + +static void +nal_header_extension(bitstream *bs, + VAEncPictureParameterBufferH264 *pic_param, + unsigned int temporal_id) +{ + int is_idr = !!pic_param->pic_fields.bits.idr_pic_flag; + + /* 3 bytes */ + bitstream_put_ui(bs, 1, 1); /* svc_extension_flag */ + bitstream_put_ui(bs, !!is_idr, 1); + bitstream_put_ui(bs, 0, 6); /* priority_id */ + bitstream_put_ui(bs, 1, 1); /* no_inter_layer_pred_flag */ + bitstream_put_ui(bs, 0, 3); /* dependency_id */ + bitstream_put_ui(bs, 0, 4); /* quality_id */ + bitstream_put_ui(bs, temporal_id, 3); /* temporal_id */ + bitstream_put_ui(bs, 0, 1); /* use_ref_base_pic_flag */ + bitstream_put_ui(bs, 1, 1); /* discardable_flag */ + bitstream_put_ui(bs, 1, 1); /* output_flag */ + bitstream_put_ui(bs, 3, 2); /* reserved_three_2bits */ +} + +static void +nal_unit_svc_prefix_rbsp(bitstream *bs, int is_ref) +{ + if (is_ref) { + bitstream_put_ui(bs, 0, 1); /* store_ref_base_pic_flag */ + bitstream_put_ui(bs, 0, 1); /* additional_prefix_nal_unit_extension_flag*/ + } else { + /* no more rbsp data */ + } + + rbsp_trailing_bits(bs); +} + +static int +build_packed_svc_prefix_nal_unit(VAEncPictureParameterBufferH264 *pic_param, + unsigned int temporal_id, + unsigned char **nal_unit_buffer) +{ + int is_ref = !!pic_param->pic_fields.bits.reference_pic_flag; + bitstream bs; + + bitstream_start(&bs); + nal_start_code_prefix(&bs); + + nal_header(&bs, is_ref ? NAL_REF_IDC_LOW : NAL_REF_IDC_NONE, NAL_PREFIX); + nal_header_extension(&bs, pic_param, temporal_id); + nal_unit_svc_prefix_rbsp(&bs, is_ref); + + bitstream_end(&bs); + *nal_unit_buffer = (unsigned char *)bs.buffer; + + return bs.bit_offset; +} + +static int +build_packed_slice_header_buffer(struct svcenc_context *ctx, + VAEncSequenceParameterBufferH264 *sps_param, + VAEncPictureParameterBufferH264 *pic_param, + VAEncSliceParameterBufferH264 *slice_param, + unsigned int reordering_info[2], + unsigned char **header_buffer) +{ + bitstream bs; + int is_idr = !!pic_param->pic_fields.bits.idr_pic_flag; + int is_ref = !!pic_param->pic_fields.bits.reference_pic_flag; + + bitstream_start(&bs); + nal_start_code_prefix(&bs); + + if (IS_I_SLICE(slice_param->slice_type)) { + nal_header(&bs, NAL_REF_IDC_HIGH, is_idr ? NAL_IDR : NAL_NON_IDR); + } else if (IS_P_SLICE(slice_param->slice_type)) { + assert(!is_idr); + nal_header(&bs, is_ref ? NAL_REF_IDC_MEDIUM : NAL_REF_IDC_NONE, NAL_NON_IDR); + } else { + assert(IS_B_SLICE(slice_param->slice_type)); + assert(!is_idr); + nal_header(&bs, is_ref ? NAL_REF_IDC_LOW : NAL_REF_IDC_NONE, NAL_NON_IDR); + } + + slice_header(&bs, sps_param, pic_param, slice_param, reordering_info); + + bitstream_end(&bs); + *header_buffer = (unsigned char *)bs.buffer; + + return bs.bit_offset; +} + +/* upload thread */ +static struct upload_task_t * +upload_task_dequeue(struct svcenc_context *ctx) +{ + struct upload_task_t *task; + + pthread_mutex_lock(&upload_mutex); + + task = ctx->upload_task_header; + + if (task) { + ctx->upload_task_header = task->next; + + if (!ctx->upload_task_header) + ctx->upload_task_tail = NULL; + } + + pthread_mutex_unlock(&upload_mutex); + + return task; +} + +static int +upload_task_queue(struct svcenc_context *ctx, unsigned int display_order, int surface) +{ + struct upload_task_t *task; + + task = calloc(1, sizeof(struct upload_task_t)); + task->display_order = display_order; + task->surface = surface; + task->next = NULL; + + pthread_mutex_lock(&upload_mutex); + + if (!ctx->upload_task_header) + ctx->upload_task_header = task; + + if (ctx->upload_task_tail) + ctx->upload_task_tail->next = task; + + ctx->upload_task_tail = task; + src_surface_status[surface] = SRC_SURFACE_IN_STORAGE; + pthread_cond_signal(&upload_cond); + + pthread_mutex_unlock(&upload_mutex); + + return 0; +} + +static void +upload_task(struct svcenc_context *ctx, unsigned int display_order, int surface) +{ + VAStatus va_status; + VAImage surface_image; + void *surface_p = NULL; + size_t n_items; + unsigned char *y_src, *u_src, *v_src; + unsigned char *y_dst, *u_dst, *v_dst; + int row, col; + int y_size = ctx->width * ctx->height; + int u_size = (ctx->width >> 1) * (ctx->height >> 1); + + fseek(ctx->ifp, ctx->frame_size * display_order, SEEK_SET); + + do { + n_items = fread(ctx->frame_data_buffer, ctx->frame_size, 1, ctx->ifp); + } while (n_items != 1); + + va_status = vaDeriveImage(ctx->va_dpy, src_surfaces[surface], &surface_image); + CHECK_VASTATUS(va_status,"vaDeriveImage"); + + vaMapBuffer(ctx->va_dpy, surface_image.buf, &surface_p); + assert(VA_STATUS_SUCCESS == va_status); + + y_src = ctx->frame_data_buffer; + u_src = ctx->frame_data_buffer + y_size; /* UV offset for NV12 */ + v_src = ctx->frame_data_buffer + y_size + u_size; + + y_dst = surface_p + surface_image.offsets[0]; + u_dst = surface_p + surface_image.offsets[1]; /* UV offset for NV12 */ + v_dst = surface_p + surface_image.offsets[2]; + + /* Y plane */ + for (row = 0; row < surface_image.height; row++) { + memcpy(y_dst, y_src, surface_image.width); + y_dst += surface_image.pitches[0]; + y_src += ctx->width; + } + + if (surface_image.format.fourcc == VA_FOURCC_NV12) { /* UV plane */ + for (row = 0; row < surface_image.height / 2; row++) { + for (col = 0; col < surface_image.width / 2; col++) { + u_dst[col * 2] = u_src[col]; + u_dst[col * 2 + 1] = v_src[col]; + } + + u_dst += surface_image.pitches[1]; + u_src += (ctx->width / 2); + v_src += (ctx->width / 2); + } + } else { + for (row = 0; row < surface_image.height / 2; row++) { + for (col = 0; col < surface_image.width / 2; col++) { + u_dst[col] = u_src[col]; + v_dst[col] = v_src[col]; + } + + u_dst += surface_image.pitches[1]; + v_dst += surface_image.pitches[2]; + u_src += (ctx->width / 2); + v_src += (ctx->width / 2); + } + } + + vaUnmapBuffer(ctx->va_dpy, surface_image.buf); + vaDestroyImage(ctx->va_dpy, surface_image.image_id); + + pthread_mutex_lock(&upload_mutex); + src_surface_status[surface] = SRC_SURFACE_IN_ENCODING; + pthread_mutex_unlock(&upload_mutex); +} + +static void * +upload_task_thread(void *data) +{ + struct svcenc_context *ctx = (struct svcenc_context *)data; + int num = 0; + + while (1) { + struct upload_task_t *task; + + task = upload_task_dequeue(ctx); + if (!task) { + pthread_mutex_lock(&upload_mutex); + pthread_cond_wait(&upload_cond, &upload_mutex); + pthread_mutex_unlock(&upload_mutex); + + continue; + } + + upload_task(ctx, task->display_order, task->surface); + free(task); + + if (++num >= ctx->num_pictures) + break; + } + + return 0; +} + +/* main thread */ +static void +usage(char *program) +{ + fprintf(stderr, "Usage: %s --help\n", program); + fprintf(stderr, "\t--help print this message\n"); + fprintf(stderr, "Usage: %s <width> <height> <ifile> <ofile> [options] \n", program); + fprintf(stderr, "\t<width>\t\tThe base picture width\n"); + fprintf(stderr, "\t<height>\tThe base picture height\n"); + fprintf(stderr, "\t<ifiles>\tThe input YUV I420 file\n"); + fprintf(stderr, "\t<ofile>\t\tThe output H.264/SVC file\n\n"); + fprintf(stderr, "\tAvailable options:\n"); + fprintf(stderr, "\t--gop <value>\t\tGOP size, default is 8\n"); + fprintf(stderr, "\t--goptype <value>\tGOP hierarchical type, 0 is P hierarchical GOP, 1 is B hierarchical GOP, default is 0\n"); + fprintf(stderr, "\t--brcmode <value>\tBRC mode, 0 is CQP mode, otherwise CBR mode, default mode is CQP\n"); + fprintf(stderr, "\t--brclayer<value>\tDisable/Enalbe BRC per temporal layer, default is disable(0)\n"); + fprintf(stderr, "\t--bitrate <value>\tbit rate in Kbps(1024 bits). It is available for CBR mode only and default value is 2000\n"); +} + +static void +svcenc_exit(struct svcenc_context *ctx, int exit_code) +{ + if (ctx->ifp) { + fclose(ctx->ifp); + ctx->ifp = NULL; + } + + if (ctx->ofp) { + fclose(ctx->ofp); + ctx->ofp = NULL; + } + + exit(exit_code); +} + +static void +parse_args(struct svcenc_context *ctx, int argc, char **argv) +{ + int c, tmp; + int option_index = 0; + long file_size; + + static struct option long_options[] = { + {"gop", required_argument, 0, 'g'}, + {"goptype", required_argument, 0, 't'}, + {"bitrate", required_argument, 0, 'b'}, + {"brcmode", required_argument, 0, 'm'}, + {"brclayer", required_argument, 0, 'l'}, + {"help", no_argument, 0, 'h'}, + { NULL, 0, NULL, 0 } + }; + + va_init_display_args(&argc, argv); + + if ((argc == 2 && strcmp(argv[1], "--help") == 0) || + (argc < 5)) + goto print_usage; + + ctx->width = atoi(argv[1]); + ctx->height = atoi(argv[2]); + + if (ctx->width <= 0 || ctx->height <= 0) { + fprintf(stderr, "<base width> and <base height> must be greater than 0\n"); + goto err_exit; + } + + ctx->frame_size = ctx->width * ctx->height * 3 / 2; + ctx->ifp = fopen(argv[3], "rb"); + + if (ctx->ifp == NULL) { + fprintf(stderr, "Can't open the input file\n"); + goto err_exit; + } + + fseek(ctx->ifp, 0l, SEEK_END); + file_size = ftell(ctx->ifp); + + if ((file_size < ctx->frame_size) || + (file_size % ctx->frame_size)) { + fprintf(stderr, "The input file size %ld isn't a multiple of the frame size %d\n", file_size, ctx->frame_size); + goto err_exit; + } + + assert(ctx->num_pictures == 0); + ctx->num_pictures = file_size / ctx->frame_size; + fseek(ctx->ifp, 0l, SEEK_SET); + + ctx->ofp = fopen(argv[4], "wb"); + + if (ctx->ofp == NULL) { + fprintf(stderr, "Can't create the output file\n"); + goto err_exit; + } + + opterr = 0; + optind = 5; + ctx->gop_size = 8; + ctx->gop_type = 0; + ctx->bits_per_kbps = -1; + ctx->rate_control_mode = VA_RC_CQP; + ctx->layer_brc = 0; + + while ((c = getopt_long(argc, argv, + "", + long_options, + &option_index)) != -1) { + switch(c) { + case 'g': + tmp = atoi(optarg); + + if ((tmp & (tmp - 1)) || + tmp > 8) { + fprintf(stderr, "Warning: invalid GOP size\n"); + tmp = 8; + } + + ctx->gop_size = tmp; + + break; + + case 't': + tmp = atoi(optarg); + + ctx->gop_type = !!tmp; + + break; + + case 'b': + tmp = atoi(optarg); + + if (tmp <= 0) + ctx->bits_per_kbps = -1; + else { + if (tmp >= 30000) + tmp = 30000; + + ctx->bits_per_kbps = tmp; + } + + break; + + case 'm': + tmp = atoi(optarg); + + if (tmp == 0) + ctx->rate_control_mode = VA_RC_CQP; + else + ctx->rate_control_mode = VA_RC_CBR; + + break; + + case 'l': + tmp = atoi(optarg); + + ctx->layer_brc = !!tmp; + + break; + + case '?': + fprintf(stderr, "Error: unkown command options\n"); + + case 'h': + goto print_usage; + } + } + + ctx->num_pictures = ((ctx->num_pictures - 1) & ~(ctx->gop_size - 1)) + 1; + + if (ctx->rate_control_mode == VA_RC_CQP) + ctx->bits_per_kbps = -1; + else { + if (ctx->bits_per_kbps == -1) + ctx->bits_per_kbps = 2000; + } + + return; + +print_usage: + usage(argv[0]); +err_exit: + svcenc_exit(ctx, 1); +} + +void +svcenc_update_ref_frames(struct svcenc_context *ctx, svcenc_surface *current_surface) +{ + int i; + + if (!current_surface->is_ref) + return; + + if (current_surface->is_idr) + ctx->num_ref_frames = 1; + else + ctx->num_ref_frames++; + + if (ctx->num_ref_frames > ctx->max_num_ref_frames) + ctx->num_ref_frames = ctx->max_num_ref_frames; + + for (i = ctx->num_ref_frames - 1; i > 0; i--) + ref_frames[i] = ref_frames[i - 1]; + + ref_frames[0] = *current_surface; +} + +static int +svcenc_coding_order_to_display_order(struct svcenc_context *ctx, int coding_order) +{ + int n, m; + int level; + + assert(coding_order > 0); + + n = (coding_order - 1) / ctx->gop_size; + m = (coding_order - 1) % ctx->gop_size; + level = ctx->hierarchical_levels - temporal_ids_in_bgop[m] - 1; + + return n * ctx->gop_size + gop_factors_in_bgop[m] * (int)pow(2.00, level); +} + +static void +update_next_picture_info(struct svcenc_context *ctx) +{ + svcenc_surface *current_surface = NULL; + svcenc_surface next_surface; + int current_frame_num; + + current_surface = &ctx->next_svcenc_surface; + current_frame_num = current_surface->frame_num; + + next_surface.coding_order = current_surface->coding_order + 1; + next_surface.display_order = svcenc_coding_order_to_display_order(ctx, next_surface.coding_order); + next_surface.slot_in_surfaces = (current_surface->slot_in_surfaces + 1) % NUM_SURFACES; + next_surface.temporal_id = temporal_ids_in_bgop[current_surface->coding_order % ctx->gop_size]; + next_surface.is_ref = (next_surface.temporal_id != ctx->hierarchical_levels - 1); + + if (next_surface.temporal_id == 0) { + if (!(next_surface.display_order % ctx->intra_period)) + next_surface.picture_type = VAEncPictureTypeIntra; + else + next_surface.picture_type = VAEncPictureTypePredictive; + } else + next_surface.picture_type = VAEncPictureTypeBidirectional; + + if (current_surface->temporal_id == ctx->hierarchical_levels - 1) + next_surface.frame_num = current_frame_num; + else + next_surface.frame_num = current_frame_num + 1; + + next_surface.is_intra = (next_surface.picture_type == VAEncPictureTypeIntra); + next_surface.is_idr = 0; + next_surface.rec_surface = rec_surfaces[next_surface.slot_in_surfaces]; + next_surface.poc = next_surface.display_order; + + if (next_surface.is_idr) + next_surface.frame_num = 0; + + *current_surface = next_surface; +} + +static int +svcenc_coding_order_to_level_pgop(struct svcenc_context *ctx, int coding_order) +{ + int m; + int level; + + assert(coding_order > 0); + + m = coding_order % ctx->gop_size; + + if (m == 0) + return 0; + + level = ctx->hierarchical_levels - temporal_ids_in_pgop[m - 1]; + + assert(level > 0 && level < 5); + + return level; +} + +static void +update_next_picture_info_pgop(struct svcenc_context *ctx) +{ + svcenc_surface *current_surface = NULL; + svcenc_surface next_surface; + int current_frame_num; + + current_surface = &ctx->next_svcenc_surface; + current_frame_num = current_surface->frame_num; + + next_surface.coding_order = current_surface->coding_order + 1; + next_surface.display_order = next_surface.coding_order; + next_surface.slot_in_surfaces = (current_surface->slot_in_surfaces + 1) % NUM_SURFACES; + next_surface.temporal_id = svcenc_coding_order_to_level_pgop(ctx, next_surface.coding_order); + next_surface.is_ref = (next_surface.temporal_id != ctx->hierarchical_levels - 1); + + if (next_surface.temporal_id == 0) { + if (!(next_surface.display_order % ctx->intra_period)) + next_surface.picture_type = VAEncPictureTypeIntra; + else + next_surface.picture_type = VAEncPictureTypePredictive; + } else { + next_surface.picture_type = VAEncPictureTypePredictive; + } + + next_surface.frame_num = current_frame_num + 1; + next_surface.is_intra = (next_surface.picture_type == VAEncPictureTypeIntra); + next_surface.is_idr = !(next_surface.display_order % ctx->intra_idr_period); + next_surface.rec_surface = rec_surfaces[next_surface.slot_in_surfaces]; + next_surface.poc = next_surface.display_order % ctx->intra_idr_period; + + if (next_surface.is_idr) { + next_surface.frame_num = 0; + assert(next_surface.poc == 0); + } + + *current_surface = next_surface; +} + +static int +svcenc_seq_parameter_set_id(struct svcenc_context *ctx, + svcenc_surface *current_surface) +{ + return 0; +} + +static int +svcenc_pic_parameter_set_id(struct svcenc_context *ctx, + svcenc_surface *current_surface) +{ + return 0; +} + +void +svcenc_update_sequence_parameter_buffer(struct svcenc_context *ctx, + svcenc_surface *current_surface) +{ + VAEncSequenceParameterBufferH264 *seq_param = &ctx->seq_param; + VAStatus va_status; + int width_in_mbs = (ctx->width + 15) / 16; + int height_in_mbs = (ctx->height + 15) / 16; + int frame_cropping_flag = 0; + int frame_crop_bottom_offset = 0; + + memset(seq_param, 0, sizeof(*seq_param)); + seq_param->seq_parameter_set_id = svcenc_seq_parameter_set_id(ctx, current_surface); + seq_param->level_idc = 41; + seq_param->intra_period = ctx->intra_period; + seq_param->ip_period = ctx->ip_period; + seq_param->intra_idr_period = ctx->intra_idr_period; + seq_param->max_num_ref_frames = ctx->max_num_ref_frames; + seq_param->picture_width_in_mbs = width_in_mbs; + seq_param->picture_height_in_mbs = height_in_mbs; + seq_param->seq_fields.bits.frame_mbs_only_flag = 1; + + if (ctx->bits_per_kbps > 0) + seq_param->bits_per_second = 1024 * ctx->bits_per_kbps; + else + seq_param->bits_per_second = 0; + + seq_param->time_scale = ctx->framerate_per_100s * 2; + seq_param->num_units_in_tick = 100; + + if (height_in_mbs * 16 - ctx->height) { + frame_cropping_flag = 1; + frame_crop_bottom_offset = + (height_in_mbs * 16 - ctx->height) / (2 * (!seq_param->seq_fields.bits.frame_mbs_only_flag + 1)); + } + + seq_param->frame_cropping_flag = frame_cropping_flag; + seq_param->frame_crop_left_offset = 0; + seq_param->frame_crop_right_offset = 0; + seq_param->frame_crop_top_offset = 0; + seq_param->frame_crop_bottom_offset = frame_crop_bottom_offset; + + seq_param->seq_fields.bits.pic_order_cnt_type = 0; + + if ((ctx->profile_idc == PROFILE_IDC_SCALABLE_HIGH && + ctx->constraint_set_flag & (1 << 3)) || + (ctx->profile_idc == PROFILE_IDC_SCALABLE_BASELINE && + ctx->constraint_set_flag & (1 << 5))) + seq_param->seq_fields.bits.direct_8x8_inference_flag = 0; + else + seq_param->seq_fields.bits.direct_8x8_inference_flag = 1; + + seq_param->seq_fields.bits.log2_max_frame_num_minus4 = 10; + seq_param->seq_fields.bits.log2_max_pic_order_cnt_lsb_minus4 = 10; + + if (ctx->bits_per_kbps > 0) + seq_param->vui_parameters_present_flag = 1; //HRD info located in vui + else + seq_param->vui_parameters_present_flag = 0; + + va_status = vaCreateBuffer(ctx->va_dpy, + ctx->context_id, + VAEncSequenceParameterBufferType, + sizeof(*seq_param), + 1, + seq_param, + &ctx->seq_param_buf_id); + CHECK_VASTATUS(va_status,"vaCreateBuffer"); +} + +void +svcenc_update_picture_parameter_buffer(struct svcenc_context *ctx, + svcenc_surface *current_surface) +{ + VAEncPictureParameterBufferH264 *pic_param; + VAStatus va_status; + int i; + + /* Allocate the new coded buffer */ + va_status = vaCreateBuffer(ctx->va_dpy, + ctx->context_id, + VAEncCodedBufferType, + ctx->frame_size, + 1, + NULL, + &ctx->codedbuf_buf_id); + assert(ctx->codedbuf_buf_id != VA_INVALID_ID); + CHECK_VASTATUS(va_status,"vaCreateBuffer"); + + /* H.264 picture parameter */ + pic_param = &ctx->pic_param; + memset(pic_param, 0, sizeof(*pic_param)); + + pic_param->seq_parameter_set_id = svcenc_seq_parameter_set_id(ctx, current_surface); + pic_param->pic_parameter_set_id = svcenc_pic_parameter_set_id(ctx, current_surface); + pic_param->last_picture = 0; + pic_param->pic_init_qp = 34; + + pic_param->num_ref_idx_l0_active_minus1 = ctx->hierarchical_levels - 1; + pic_param->num_ref_idx_l1_active_minus1 = ctx->hierarchical_levels - 1; + + pic_param->coded_buf = ctx->codedbuf_buf_id; + pic_param->frame_num = current_surface->frame_num; + + pic_param->CurrPic.picture_id = current_surface->rec_surface; + pic_param->CurrPic.TopFieldOrderCnt = current_surface->poc * 2; + pic_param->CurrPic.BottomFieldOrderCnt = pic_param->CurrPic.TopFieldOrderCnt; + pic_param->CurrPic.frame_idx = current_surface->frame_num; + pic_param->CurrPic.flags = 0; /* frame */ + + for (i = 0; i < ctx->num_ref_frames; i++) { + assert(pic_param->CurrPic.picture_id != ref_frames[i].rec_surface); + + pic_param->ReferenceFrames[i].picture_id = ref_frames[i].rec_surface; + pic_param->ReferenceFrames[i].TopFieldOrderCnt = ref_frames[i].poc * 2; + pic_param->ReferenceFrames[i].BottomFieldOrderCnt = pic_param[i].ReferenceFrames[i].TopFieldOrderCnt; + pic_param->ReferenceFrames[i].flags = VA_PICTURE_H264_SHORT_TERM_REFERENCE; + } + + for (; i < 16; i++) { + pic_param->ReferenceFrames[i].picture_id = VA_INVALID_ID; + pic_param->ReferenceFrames[i].flags = VA_PICTURE_H264_INVALID; + } + + pic_param->pic_fields.bits.entropy_coding_mode_flag = ENTROPY_MODE_CAVLC; + pic_param->pic_fields.bits.weighted_pred_flag = 0; + pic_param->pic_fields.bits.weighted_bipred_idc = 0; + pic_param->pic_fields.bits.idr_pic_flag = !!current_surface->is_idr; + pic_param->pic_fields.bits.reference_pic_flag = !!current_surface->is_ref; + pic_param->pic_fields.bits.deblocking_filter_control_present_flag = 1; + + if (ctx->profile_idc == PROFILE_IDC_BASELINE || + ctx->profile_idc == PROFILE_IDC_MAIN || + ctx->profile_idc == PROFILE_IDC_SCALABLE_BASELINE) + pic_param->pic_fields.bits.transform_8x8_mode_flag = 0; + else + pic_param->pic_fields.bits.transform_8x8_mode_flag = 0; + + /* Allocate the new picture parameter buffer */ + va_status = vaCreateBuffer(ctx->va_dpy, + ctx->context_id, + VAEncPictureParameterBufferType, + sizeof(*pic_param), + 1, + pic_param, + &ctx->pic_param_buf_id); + assert(ctx->pic_param_buf_id != VA_INVALID_ID); + CHECK_VASTATUS(va_status,"vaCreateBuffer"); +} + +#define partition(ref, field, key, ascending) \ + while (i <= j) { \ + if (ascending) { \ + while (ref[i].field < key) \ + i++; \ + while (ref[j].field > key) \ + j--; \ + } else { \ + while (ref[i].field > key) \ + i++; \ + while (ref[j].field < key) \ + j--; \ + } \ + if (i <= j) { \ + tmp = ref[i]; \ + ref[i] = ref[j]; \ + ref[j] = tmp; \ + i++; \ + j--; \ + } \ + } \ + +static void +sort_one(svcenc_surface ref[], + int left, int right, + int ascending, int is_frame_num) +{ + int i = left, j = right; + int key; + svcenc_surface tmp; + + if (is_frame_num) { + key = ref[(left + right) / 2].frame_num; + partition(ref, frame_num, key, ascending); + } else { + key = ref[(left + right) / 2].display_order; + partition(ref, display_order, (signed int)key, ascending); + } + + /* recursion */ + if (left < j) + sort_one(ref, left, j, ascending, is_frame_num); + + if (i < right) + sort_one(ref, i, right, ascending, is_frame_num); +} + +static void +sort_two(svcenc_surface ref[], + int left, int right, + int key, int is_frame_num, + int partition_ascending, + int list0_ascending, int list1_ascending) +{ + int i = left, j = right; + svcenc_surface tmp; + + if (is_frame_num) { + partition(ref, frame_num, key, partition_ascending); + } else { + partition(ref, display_order, key, partition_ascending); + } + + sort_one(ref, left, i - 1, list0_ascending, is_frame_num); + sort_one(ref, j + 1, right, list1_ascending, is_frame_num); +} + +static void +svcenc_update_ref_lists(struct svcenc_context *ctx, + svcenc_surface *current_surface) +{ + if (current_surface->picture_type == VAEncPictureTypePredictive) { + memcpy(ref_list0, ref_frames, ctx->num_ref_frames * sizeof(svcenc_surface)); + sort_one(ref_list0, 0, ctx->num_ref_frames - 1, 0, 1); + } else if (current_surface->picture_type == VAEncPictureTypeBidirectional) { + memcpy(ref_list0, ref_frames, ctx->num_ref_frames * sizeof(svcenc_surface)); + sort_two(ref_list0, + 0, ctx->num_ref_frames - 1, + current_surface->display_order, 0, + 1, + 0, 1); + memcpy(ref_list1, ref_frames, ctx->num_ref_frames * sizeof(svcenc_surface)); + sort_two(ref_list1, + 0, ctx->num_ref_frames - 1, + current_surface->display_order, 0, + 0, + 1, 0); + } +} + +static int +avc_temporal_find_surface(VAPictureH264 *curr_pic, + VAPictureH264 *ref_list, + int num_pictures, + int dir) +{ + int i, found = -1, min = 0x7FFFFFFF; + + for (i = 0; i < num_pictures; i++) { + int tmp; + + if ((ref_list[i].flags & VA_PICTURE_H264_INVALID) || + (ref_list[i].picture_id == VA_INVALID_SURFACE)) + break; + + tmp = curr_pic->TopFieldOrderCnt - ref_list[i].TopFieldOrderCnt; + + if (dir) + tmp = -tmp; + + if (tmp > 0 && tmp < min) { + min = tmp; + found = i; + } + } + + return found; +} + +static int +avc_temporal_find_surface_pgop(svcenc_surface *curr_pic, + svcenc_surface *ref_list, + int num_pictures) +{ + int i, found = -1, min = 0x7FFFFFFF; + + for (i = 0; i < num_pictures; i++) { + int tmp; + + if (ref_list[i].rec_surface == VA_INVALID_SURFACE) + break; + + if (curr_pic->temporal_id < ref_list[i].temporal_id) + continue; + + tmp = curr_pic->display_order - ref_list[i].display_order; + + if (tmp > 0 && tmp < min) { + min = tmp; + found = i; + } + } + + assert(found != -1); + + return found; +} + +void +svcenc_update_slice_parameter_buffer(struct svcenc_context *ctx, + svcenc_surface *current_surface) +{ + VAEncPictureParameterBufferH264 *pic_param = &ctx->pic_param; + VAEncSliceParameterBufferH264 *slice_param; + VAStatus va_status; + int i, width_in_mbs, height_in_mbs; + int slice_type; + int num_ref_idx_active_override_flag = 0, num_ref_l0 = 1, num_ref_l1 = 1; + VAPictureH264 RefPicList0[32]; + VAPictureH264 RefPicList1[32]; + VAPictureH264 *curr_pic; + int ref_idx; + + svcenc_update_ref_lists(ctx, current_surface); + + switch (current_surface->picture_type) { + case VAEncPictureTypeBidirectional: + slice_type = SLICE_TYPE_B; + break; + + case VAEncPictureTypePredictive: + slice_type = SLICE_TYPE_P; + break; + + case VAEncPictureTypeIntra: + default: + slice_type = SLICE_TYPE_I; + break; + } + + width_in_mbs = (ctx->width + 15) / 16; + height_in_mbs = (ctx->height + 15) / 16; + + // Slice level + i = 0; + slice_param = &ctx->slice_param[i]; + memset(slice_param, 0, sizeof(*slice_param)); + + slice_param->macroblock_address = 0; + slice_param->num_macroblocks = height_in_mbs * width_in_mbs; + slice_param->pic_parameter_set_id = svcenc_pic_parameter_set_id(ctx, current_surface); + slice_param->slice_type = slice_type; + + slice_param->direct_spatial_mv_pred_flag = 1; /* + * It is required for the slice layer extension and the base + * layer bitstream + * See G.7.4.3 j), G.10.1.2 a), G.10.1.2.1 a) + */ + slice_param->num_ref_idx_active_override_flag = 0; + slice_param->num_ref_idx_l0_active_minus1 = 0; + slice_param->num_ref_idx_l1_active_minus1 = 0; + slice_param->cabac_init_idc = 0; + slice_param->slice_qp_delta = 0; + slice_param->disable_deblocking_filter_idc = 0; + slice_param->slice_alpha_c0_offset_div2 = 2; + slice_param->slice_beta_offset_div2 = 2; + slice_param->idr_pic_id = 0; + + ctx->reordering_info[0] = ctx->reordering_info[1] = 0; + + /* FIXME: fill other fields */ + if ((slice_type == SLICE_TYPE_P) || (slice_type == SLICE_TYPE_B)) { + int j; + num_ref_l0 = MIN((pic_param->num_ref_idx_l0_active_minus1 + 1), ctx->num_ref_frames); + + for (j = 0; j < num_ref_l0; j++) { + RefPicList0[j].picture_id = ref_list0[j].rec_surface; + RefPicList0[j].TopFieldOrderCnt = ref_list0[j].poc * 2; + RefPicList0[j].BottomFieldOrderCnt = RefPicList0[j].TopFieldOrderCnt; + RefPicList0[j].frame_idx = ref_list0[j].frame_num; + RefPicList0[j].flags = VA_PICTURE_H264_SHORT_TERM_REFERENCE; + } + + for (; j < 32; j++) { + RefPicList0[j].picture_id = VA_INVALID_SURFACE; + RefPicList0[j].flags = VA_PICTURE_H264_INVALID; + } + + if (num_ref_l0 != pic_param->num_ref_idx_l0_active_minus1 + 1) + num_ref_idx_active_override_flag = 1; + } + + if ((slice_type == SLICE_TYPE_B)) { + int j; + num_ref_l1 = MIN((pic_param->num_ref_idx_l1_active_minus1 + 1), ctx->num_ref_frames); + + for (j = 0; j < num_ref_l1; j++) { + RefPicList1[j].picture_id = ref_list1[j].rec_surface; + RefPicList1[j].TopFieldOrderCnt = ref_list1[j].poc * 2; + RefPicList1[j].BottomFieldOrderCnt = RefPicList1[j].TopFieldOrderCnt; + RefPicList1[j].frame_idx = ref_list1[j].frame_num; + RefPicList1[j].flags = VA_PICTURE_H264_SHORT_TERM_REFERENCE; + } + + for (; j < 32; j++) { + RefPicList1[j].picture_id = VA_INVALID_SURFACE; + RefPicList1[j].flags = VA_PICTURE_H264_INVALID; + } + + if (num_ref_l1 != pic_param->num_ref_idx_l1_active_minus1 + 1) + num_ref_idx_active_override_flag = 1; + } + + if (num_ref_l0 != 1 || num_ref_l1 != 1) { + curr_pic = &pic_param->CurrPic; + + /* select the reference frame in temporal space */ + if ((slice_type == SLICE_TYPE_P) || (slice_type == SLICE_TYPE_B)) { + if (ctx->gop_type == 1) + ref_idx = avc_temporal_find_surface(curr_pic, RefPicList0, num_ref_l0, 0); + else + ref_idx = avc_temporal_find_surface_pgop(current_surface, ref_list0, num_ref_l0); + + if (ref_idx != 0) { + ctx->reordering_info[0] |= (1 << 0); + + if (curr_pic->frame_idx > RefPicList0[ref_idx].frame_idx) { + ctx->reordering_info[0] |= (0 << 4); + ctx->reordering_info[0] |= ((curr_pic->frame_idx - RefPicList0[ref_idx].frame_idx - 1) << 8); + } else { + ctx->reordering_info[0] |= (1 << 4); + ctx->reordering_info[0] |= ((RefPicList0[ref_idx].frame_idx - curr_pic->frame_idx - 1) << 8); + } + } + + slice_param->RefPicList0[0] = RefPicList0[ref_idx]; + } + + if (slice_type == SLICE_TYPE_B) { + assert(ctx->gop_type == 1); + ref_idx = avc_temporal_find_surface(curr_pic, RefPicList1, num_ref_l1, 1); + + if (ref_idx != 0) { + ctx->reordering_info[1] |= (1 << 0); + + if (curr_pic->frame_idx > RefPicList1[ref_idx].frame_idx) { + ctx->reordering_info[1] |= (0 << 4); + ctx->reordering_info[1] |= ((curr_pic->frame_idx - RefPicList1[ref_idx].frame_idx - 1) << 8); + } else { + ctx->reordering_info[1] |= (1 << 4); + ctx->reordering_info[1] |= ((RefPicList1[ref_idx].frame_idx - curr_pic->frame_idx - 1) << 8); + } + } + + slice_param->RefPicList1[0] = RefPicList1[ref_idx]; + } + + slice_param->num_ref_idx_active_override_flag = 1; + slice_param->num_ref_idx_l0_active_minus1 = 0; + slice_param->num_ref_idx_l1_active_minus1 = 0; + ctx->reordering_info[0] |= ((1 << 16) | (0 << 24)); + ctx->reordering_info[1] |= ((1 << 16) | (0 << 24)); + } else { + if (num_ref_idx_active_override_flag == 1) { + slice_param->num_ref_idx_active_override_flag = 1; + slice_param->num_ref_idx_l0_active_minus1 = 0; + slice_param->num_ref_idx_l1_active_minus1 = 0; + ctx->reordering_info[0] |= ((1 << 16) | (0 << 24)); + ctx->reordering_info[1] |= ((1 << 16) | (0 << 24)); + } + + if ((slice_type == SLICE_TYPE_P) || (slice_type == SLICE_TYPE_B)) { + slice_param->RefPicList0[0] = RefPicList0[0]; + } + + if (slice_type == SLICE_TYPE_B) { + slice_param->RefPicList1[0] = RefPicList1[0]; + } + } + + va_status = vaCreateBuffer(ctx->va_dpy, + ctx->context_id, + VAEncSliceParameterBufferType, + sizeof(*slice_param), + 1, + slice_param, + &ctx->slice_param_buf_id[i]); + CHECK_VASTATUS(va_status,"vaCreateBuffer");; + + ctx->num_slices = ++i; +} + +void +svcenc_update_misc_parameter_buffer(struct svcenc_context *ctx, svcenc_surface *current_surface) +{ + VAStatus va_status; + VAEncMiscParameterBuffer *misc_param; + VAEncMiscParameterTemporalLayerStructure *misc_layer_structure_param; + VAEncMiscParameterRateControl *misc_ratecontrol_param; + VAEncMiscParameterFrameRate *misc_framerate_param; + VAEncMiscParameterHRD *misc_hrd_param; + + if (current_surface->frame_num != 0) + return; + + if (ctx->rate_control_mode & VA_RC_CQP) + return; + + assert(ctx->bits_per_kbps > 0); + + if (!ctx->layer_brc) { + va_status = vaCreateBuffer(ctx->va_dpy, + ctx->context_id, + VAEncMiscParameterBufferType, + sizeof(VAEncMiscParameterBuffer) + sizeof(VAEncMiscParameterRateControl), + 1, + NULL, + &ctx->misc_parameter_ratecontrol_buf_id[0]); + CHECK_VASTATUS(va_status, "vaCreateBuffer"); + + vaMapBuffer(ctx->va_dpy, + ctx->misc_parameter_ratecontrol_buf_id[0], + (void **)&misc_param); + + misc_param->type = VAEncMiscParameterTypeRateControl; + misc_ratecontrol_param = (VAEncMiscParameterRateControl *)misc_param->data; + + misc_ratecontrol_param->bits_per_second = 1024 * ctx->bits_per_kbps; + + vaUnmapBuffer(ctx->va_dpy, ctx->misc_parameter_ratecontrol_buf_id[0]); + + va_status = vaCreateBuffer(ctx->va_dpy, + ctx->context_id, + VAEncMiscParameterBufferType, + sizeof(VAEncMiscParameterBuffer) + sizeof(VAEncMiscParameterFrameRate), + 1, + NULL, + &ctx->misc_parameter_framerate_buf_id[0]); + CHECK_VASTATUS(va_status, "vaCreateBuffer"); + + vaMapBuffer(ctx->va_dpy, + ctx->misc_parameter_framerate_buf_id[0], + (void **)&misc_param); + + misc_param->type = VAEncMiscParameterTypeFrameRate; + misc_framerate_param = (VAEncMiscParameterFrameRate *)misc_param->data; + misc_framerate_param->framerate = ((100 << 16) | ctx->framerate_per_100s); + + misc_ratecontrol_param->bits_per_second = 1024 * ctx->bits_per_kbps; + + vaUnmapBuffer(ctx->va_dpy, ctx->misc_parameter_ratecontrol_buf_id[0]); + + va_status = vaCreateBuffer(ctx->va_dpy, + ctx->context_id, + VAEncMiscParameterBufferType, + sizeof(VAEncMiscParameterBuffer) + sizeof(VAEncMiscParameterHRD), + 1, + NULL, + &ctx->misc_parameter_hrd_buf_id); + CHECK_VASTATUS(va_status, "vaCreateBuffer"); + + vaMapBuffer(ctx->va_dpy, + ctx->misc_parameter_hrd_buf_id, + (void **)&misc_param); + + misc_param->type = VAEncMiscParameterTypeHRD; + misc_hrd_param = (VAEncMiscParameterHRD *)misc_param->data; + + misc_hrd_param->initial_buffer_fullness = ctx->bits_per_kbps * 1024 * 4; + misc_hrd_param->buffer_size = ctx->bits_per_kbps * 1024 * 8; + + vaUnmapBuffer(ctx->va_dpy, ctx->misc_parameter_hrd_buf_id); + } else { + int i, j, nlayers = 0; + + va_status = vaCreateBuffer(ctx->va_dpy, + ctx->context_id, + VAEncMiscParameterBufferType, + sizeof(VAEncMiscParameterBuffer) + sizeof(VAEncMiscParameterTemporalLayerStructure), + 1, + NULL, + &ctx->misc_parameter_layer_structure_buf_id); + CHECK_VASTATUS(va_status, "vaCreateBuffer"); + + vaMapBuffer(ctx->va_dpy, + ctx->misc_parameter_layer_structure_buf_id, + (void **)&misc_param); + + misc_param->type = VAEncMiscParameterTypeTemporalLayerStructure; + misc_layer_structure_param = (VAEncMiscParameterTemporalLayerStructure *)misc_param->data; + + misc_layer_structure_param->number_of_layers = ctx->hierarchical_levels; + misc_layer_structure_param->periodicity = ctx->gop_size; + + for (i = 0; i < ctx->gop_size; i++) { + if (ctx->gop_type == 1) { // B + misc_layer_structure_param->layer_id[i] = temporal_ids_in_bgop[i]; + } else { + misc_layer_structure_param->layer_id[i] = svcenc_coding_order_to_level_pgop(ctx, i + 1); + } + } + + vaUnmapBuffer(ctx->va_dpy, ctx->misc_parameter_layer_structure_buf_id); + + for (i = 1; i <= ctx->hierarchical_levels; i++) { + nlayers += i; + } + + for (i = 0; i < ctx->hierarchical_levels; i++) { + int framerate_per_100s = frame_rates[i] * 100; + int numerator = 0; + + for (j = 0; j < ctx->gop_size; j++) { + if (misc_layer_structure_param->layer_id[j] <= i) + numerator++; + } + + va_status = vaCreateBuffer(ctx->va_dpy, + ctx->context_id, + VAEncMiscParameterBufferType, + sizeof(VAEncMiscParameterBuffer) + sizeof(VAEncMiscParameterRateControl), + 1, + NULL, + &ctx->misc_parameter_ratecontrol_buf_id[i]); + CHECK_VASTATUS(va_status, "vaCreateBuffer"); + + vaMapBuffer(ctx->va_dpy, + ctx->misc_parameter_ratecontrol_buf_id[i], + (void **)&misc_param); + + misc_param->type = VAEncMiscParameterTypeRateControl; + misc_ratecontrol_param = (VAEncMiscParameterRateControl *)misc_param->data; + misc_ratecontrol_param->bits_per_second = 1024 * ctx->bits_per_kbps * ((float)numerator / ctx->gop_size); + misc_ratecontrol_param->rc_flags.bits.temporal_id = i; + + vaUnmapBuffer(ctx->va_dpy, ctx->misc_parameter_ratecontrol_buf_id[i]); + + va_status = vaCreateBuffer(ctx->va_dpy, + ctx->context_id, + VAEncMiscParameterBufferType, + sizeof(VAEncMiscParameterBuffer) + sizeof(VAEncMiscParameterFrameRate), + 1, + NULL, + &ctx->misc_parameter_framerate_buf_id[i]); + CHECK_VASTATUS(va_status, "vaCreateBuffer"); + + vaMapBuffer(ctx->va_dpy, + ctx->misc_parameter_framerate_buf_id[i], + (void **)&misc_param); + + misc_param->type = VAEncMiscParameterTypeFrameRate; + misc_framerate_param = (VAEncMiscParameterFrameRate *)misc_param->data; + misc_framerate_param->framerate = ((100 << 16) | framerate_per_100s); + misc_framerate_param->framerate_flags.bits.temporal_id = i; + + vaUnmapBuffer(ctx->va_dpy, ctx->misc_parameter_ratecontrol_buf_id[i]); + } + + va_status = vaCreateBuffer(ctx->va_dpy, + ctx->context_id, + VAEncMiscParameterBufferType, + sizeof(VAEncMiscParameterBuffer) + sizeof(VAEncMiscParameterHRD), + 1, + NULL, + &ctx->misc_parameter_hrd_buf_id); + CHECK_VASTATUS(va_status, "vaCreateBuffer"); + + vaMapBuffer(ctx->va_dpy, + ctx->misc_parameter_hrd_buf_id, + (void **)&misc_param); + + misc_param->type = VAEncMiscParameterTypeHRD; + misc_hrd_param = (VAEncMiscParameterHRD *)misc_param->data; + + misc_hrd_param->initial_buffer_fullness = ctx->bits_per_kbps * 1024 * 4; + misc_hrd_param->buffer_size = ctx->bits_per_kbps * 1024 * 8; + + vaUnmapBuffer(ctx->va_dpy, ctx->misc_parameter_hrd_buf_id); + } +} + +static void +svcenc_update_packed_slice_header_buffer(struct svcenc_context *ctx, unsigned int temporal_id) +{ + VAStatus va_status; + VAEncPackedHeaderParameterBuffer packed_header_param_buffer; + unsigned int length_in_bits; + unsigned char *packed_header_data_buffer = NULL; + int i; + + for (i = 0; i < ctx->num_slices; i++) { + length_in_bits = build_packed_svc_prefix_nal_unit(&ctx->pic_param, + temporal_id, + &packed_header_data_buffer); + + packed_header_param_buffer.type = VAEncPackedHeaderRawData; + packed_header_param_buffer.bit_length = length_in_bits; + packed_header_param_buffer.has_emulation_bytes = 0; + + va_status = vaCreateBuffer(ctx->va_dpy, + ctx->context_id, + VAEncPackedHeaderParameterBufferType, + sizeof(packed_header_param_buffer), + 1, + &packed_header_param_buffer, + &ctx->packed_prefix_nal_unit_param_buf_id[i]); + CHECK_VASTATUS(va_status,"vaCreateBuffer"); + + va_status = vaCreateBuffer(ctx->va_dpy, + ctx->context_id, + VAEncPackedHeaderDataBufferType, + (length_in_bits + 7) / 8, + 1, + packed_header_data_buffer, + &ctx->packed_prefix_nal_unit_data_buf_id[i]); + CHECK_VASTATUS(va_status,"vaCreateBuffer"); + + free(packed_header_data_buffer); + + length_in_bits = build_packed_slice_header_buffer(ctx, + &ctx->seq_param, + &ctx->pic_param, + &ctx->slice_param[i], + ctx->reordering_info, + &packed_header_data_buffer); + + packed_header_param_buffer.type = VAEncPackedHeaderSlice; + packed_header_param_buffer.bit_length = length_in_bits; + packed_header_param_buffer.has_emulation_bytes = 0; + + va_status = vaCreateBuffer(ctx->va_dpy, + ctx->context_id, + VAEncPackedHeaderParameterBufferType, + sizeof(packed_header_param_buffer), + 1, + &packed_header_param_buffer, + &ctx->packed_slice_header_param_buf_id[i]); + CHECK_VASTATUS(va_status,"vaCreateBuffer"); + + va_status = vaCreateBuffer(ctx->va_dpy, + ctx->context_id, + VAEncPackedHeaderDataBufferType, + (length_in_bits + 7) / 8, + 1, + packed_header_data_buffer, + &ctx->packed_slice_header_data_buf_id[i]); + CHECK_VASTATUS(va_status,"vaCreateBuffer"); + + free(packed_header_data_buffer); + } +} + +void +svcenc_update_packed_buffers(struct svcenc_context *ctx, + svcenc_surface *current_surface) +{ + VAStatus va_status; + VAEncPackedHeaderParameterBuffer packed_header_param_buffer; + unsigned int length_in_bits; + unsigned char *packed_seq_buffer = NULL, *packed_pic_buffer = NULL, *packed_sei_buffer = NULL; + + length_in_bits = build_packed_sei_buffer(ctx, + &ctx->seq_param, + &ctx->pic_param, + current_surface, + &packed_sei_buffer); + + if (packed_sei_buffer) { + assert(length_in_bits); + + packed_header_param_buffer.type = VAEncPackedHeaderH264_SEI; + packed_header_param_buffer.bit_length = length_in_bits; + packed_header_param_buffer.has_emulation_bytes = 0; + va_status = vaCreateBuffer(ctx->va_dpy, + ctx->context_id, + VAEncPackedHeaderParameterBufferType, + sizeof(packed_header_param_buffer), + 1, + &packed_header_param_buffer, + &ctx->packed_sei_header_param_buf_id); + CHECK_VASTATUS(va_status,"vaCreateBuffer"); + + va_status = vaCreateBuffer(ctx->va_dpy, + ctx->context_id, + VAEncPackedHeaderDataBufferType, + (length_in_bits + 7) / 8, + 1, + packed_sei_buffer, + &ctx->packed_sei_buf_id); + CHECK_VASTATUS(va_status,"vaCreateBuffer"); + + free(packed_sei_buffer); + } + + if (current_surface->frame_num == 0) { + int save_profile_idc, save_constraint_set_flag; + unsigned char *packed_svc_seq_buffer = NULL; + + length_in_bits = build_packed_seq_buffer(ctx, + &ctx->seq_param, + &packed_seq_buffer); + + packed_header_param_buffer.type = VAEncPackedHeaderH264_SPS; + packed_header_param_buffer.bit_length = length_in_bits; + packed_header_param_buffer.has_emulation_bytes = 0; + va_status = vaCreateBuffer(ctx->va_dpy, + ctx->context_id, + VAEncPackedHeaderParameterBufferType, + sizeof(packed_header_param_buffer), + 1, + &packed_header_param_buffer, + &ctx->packed_seq_header_param_buf_id); + CHECK_VASTATUS(va_status,"vaCreateBuffer"); + + va_status = vaCreateBuffer(ctx->va_dpy, + ctx->context_id, + VAEncPackedHeaderDataBufferType, + (length_in_bits + 7) / 8, + 1, + packed_seq_buffer, + &ctx->packed_seq_buf_id); + CHECK_VASTATUS(va_status,"vaCreateBuffer"); + + save_profile_idc = ctx->profile_idc; + save_constraint_set_flag = ctx->constraint_set_flag; + ctx->profile_idc = ctx->svc_profile_idc; + ctx->constraint_set_flag = ctx->svc_constraint_set_flag; + + length_in_bits = build_packed_subset_seq_buffer(ctx, + &ctx->seq_param, + &packed_svc_seq_buffer); + packed_header_param_buffer.type = VAEncPackedHeaderRawData; + packed_header_param_buffer.bit_length = length_in_bits; + packed_header_param_buffer.has_emulation_bytes = 0; + va_status = vaCreateBuffer(ctx->va_dpy, + ctx->context_id, + VAEncPackedHeaderParameterBufferType, + sizeof(packed_header_param_buffer), + 1, + &packed_header_param_buffer, + &ctx->packed_svc_seq_header_param_buf_id); + CHECK_VASTATUS(va_status,"vaCreateBuffer"); + + va_status = vaCreateBuffer(ctx->va_dpy, + ctx->context_id, + VAEncPackedHeaderDataBufferType, + (length_in_bits + 7) / 8, + 1, + packed_svc_seq_buffer, + &ctx->packed_svc_seq_buf_id); + CHECK_VASTATUS(va_status,"vaCreateBuffer"); + + ctx->profile_idc = save_profile_idc; + ctx->constraint_set_flag = save_constraint_set_flag; + + free(packed_svc_seq_buffer); + + length_in_bits = build_packed_pic_buffer(ctx, + &ctx->pic_param, + &packed_pic_buffer); + packed_header_param_buffer.type = VAEncPackedHeaderH264_PPS; + packed_header_param_buffer.bit_length = length_in_bits; + packed_header_param_buffer.has_emulation_bytes = 0; + + va_status = vaCreateBuffer(ctx->va_dpy, + ctx->context_id, + VAEncPackedHeaderParameterBufferType, + sizeof(packed_header_param_buffer), + 1, + &packed_header_param_buffer, + &ctx->packed_pic_header_param_buf_id); + CHECK_VASTATUS(va_status,"vaCreateBuffer"); + + va_status = vaCreateBuffer(ctx->va_dpy, + ctx->context_id, + VAEncPackedHeaderDataBufferType, + (length_in_bits + 7) / 8, + 1, + packed_pic_buffer, + &ctx->packed_pic_buf_id); + CHECK_VASTATUS(va_status,"vaCreateBuffer"); + + free(packed_seq_buffer); + free(packed_pic_buffer); + } + + svcenc_update_packed_slice_header_buffer(ctx, current_surface->temporal_id); +} + +void +svcenc_update_profile_idc(struct svcenc_context *ctx, + svcenc_surface *current_surface) +{ + ctx->profile_idc = PROFILE_IDC_HIGH; + ctx->constraint_set_flag = 0; + + switch (ctx->profile) { + case VAProfileH264High: + ctx->profile_idc = PROFILE_IDC_HIGH; + ctx->constraint_set_flag |= (1 << 1); + break; + + case VAProfileH264ConstrainedBaseline: + case VAProfileH264Baseline: + ctx->profile_idc = PROFILE_IDC_BASELINE; + ctx->constraint_set_flag |= (1 << 0 | + 1 << 1 | + 1 << 2); + break; + + default: + /* Never get here !!! */ + assert(0); + break; + } + + ctx->svc_profile_idc = PROFILE_IDC_SCALABLE_HIGH; + ctx->svc_constraint_set_flag = 0; + + switch (ctx->profile) { + case VAProfileH264High: + ctx->svc_profile_idc = PROFILE_IDC_SCALABLE_HIGH; + ctx->svc_constraint_set_flag |= (1 << 1); + break; + + case VAProfileH264ConstrainedBaseline: + ctx->svc_profile_idc = PROFILE_IDC_SCALABLE_BASELINE; + ctx->svc_constraint_set_flag |= (1 << 0 | 1 << 1 | 1 << 5); + break; + + case VAProfileH264Baseline: + ctx->svc_profile_idc = PROFILE_IDC_SCALABLE_BASELINE; + ctx->svc_constraint_set_flag |= (1 << 0); + break; + + default: + /* Never get here !!! */ + assert(0); + break; + } +} + +int +begin_picture(struct svcenc_context *ctx, + svcenc_surface *current_surface) +{ + svcenc_update_profile_idc(ctx, current_surface); + svcenc_update_sequence_parameter_buffer(ctx, current_surface); + svcenc_update_picture_parameter_buffer(ctx, current_surface); + svcenc_update_slice_parameter_buffer(ctx, current_surface); + svcenc_update_misc_parameter_buffer(ctx, current_surface); + svcenc_update_packed_buffers(ctx, current_surface); + + return 0; +} + +static int +svcenc_store_coded_buffer(struct svcenc_context *ctx, + svcenc_surface *current_surface) +{ + VACodedBufferSegment *coded_buffer_segment; + unsigned char *coded_mem; + int slice_data_length; + VAStatus va_status; + size_t w_items; + + va_status = vaSyncSurface(ctx->va_dpy, src_surfaces[current_surface->slot_in_surfaces]); + CHECK_VASTATUS(va_status,"vaSyncSurface"); + + va_status = vaMapBuffer(ctx->va_dpy, ctx->codedbuf_buf_id, (void **)(&coded_buffer_segment)); + CHECK_VASTATUS(va_status,"vaMapBuffer"); + + coded_mem = coded_buffer_segment->buf; + + if (coded_buffer_segment->status & VA_CODED_BUF_STATUS_SLICE_OVERFLOW_MASK) { + /* Fatal error !!! */ + assert(0); + } + + slice_data_length = coded_buffer_segment->size; + + do { + w_items = fwrite(coded_mem, slice_data_length, 1, ctx->ofp); + } while (w_items != 1); + + vaUnmapBuffer(ctx->va_dpy, ctx->codedbuf_buf_id); + + return 0; +} + +int +render_picture(struct svcenc_context *ctx, + svcenc_surface *current_surface) +{ + VAStatus va_status; + VABufferID va_buffers[32]; + unsigned int num_va_buffers = 0; + int i; + + va_buffers[num_va_buffers++] = ctx->seq_param_buf_id; + va_buffers[num_va_buffers++] = ctx->pic_param_buf_id; + + if (ctx->packed_sei_scalability_info_header_param_buf_id != VA_INVALID_ID) + va_buffers[num_va_buffers++] = ctx->packed_sei_scalability_info_header_param_buf_id; + + if (ctx->packed_sei_scalability_info_buf_id != VA_INVALID_ID) + va_buffers[num_va_buffers++] = ctx->packed_sei_scalability_info_buf_id; + + if (ctx->packed_seq_header_param_buf_id != VA_INVALID_ID) + va_buffers[num_va_buffers++] = ctx->packed_seq_header_param_buf_id; + + if (ctx->packed_seq_buf_id != VA_INVALID_ID) + va_buffers[num_va_buffers++] = ctx->packed_seq_buf_id; + + if (ctx->packed_svc_seq_header_param_buf_id != VA_INVALID_ID) + va_buffers[num_va_buffers++] = ctx->packed_svc_seq_header_param_buf_id; + + if (ctx->packed_svc_seq_buf_id != VA_INVALID_ID) + va_buffers[num_va_buffers++] = ctx->packed_svc_seq_buf_id; + + if (ctx->packed_pic_header_param_buf_id != VA_INVALID_ID) + va_buffers[num_va_buffers++] = ctx->packed_pic_header_param_buf_id; + + if (ctx->packed_pic_buf_id != VA_INVALID_ID) + va_buffers[num_va_buffers++] = ctx->packed_pic_buf_id; + + if (ctx->packed_sei_header_param_buf_id != VA_INVALID_ID) + va_buffers[num_va_buffers++] = ctx->packed_sei_header_param_buf_id; + + if (ctx->packed_sei_buf_id != VA_INVALID_ID) + va_buffers[num_va_buffers++] = ctx->packed_sei_buf_id; + + if (ctx->misc_parameter_layer_structure_buf_id != VA_INVALID_ID) + va_buffers[num_va_buffers++] = ctx->misc_parameter_layer_structure_buf_id; + + for (i = 0; i < MAX_LAYERS; i++) { + if (ctx->misc_parameter_ratecontrol_buf_id[i] != VA_INVALID_ID) + va_buffers[num_va_buffers++] = ctx->misc_parameter_ratecontrol_buf_id[i]; + + if (ctx->misc_parameter_framerate_buf_id[i] != VA_INVALID_ID) + va_buffers[num_va_buffers++] = ctx->misc_parameter_framerate_buf_id[i]; + } + + if (ctx->misc_parameter_hrd_buf_id != VA_INVALID_ID) + va_buffers[num_va_buffers++] = ctx->misc_parameter_hrd_buf_id; + + va_status = vaBeginPicture(ctx->va_dpy, + ctx->context_id, + src_surfaces[current_surface->slot_in_surfaces]); + CHECK_VASTATUS(va_status,"vaBeginPicture"); + + va_status = vaRenderPicture(ctx->va_dpy, + ctx->context_id, + va_buffers, + num_va_buffers); + CHECK_VASTATUS(va_status,"vaRenderPicture"); + + for (i = 0; i < ctx->num_slices; i++) { + va_status = vaRenderPicture(ctx->va_dpy, + ctx->context_id, + &ctx->packed_prefix_nal_unit_param_buf_id[i], + 1); + CHECK_VASTATUS(va_status,"vaRenderPicture"); + + va_status = vaRenderPicture(ctx->va_dpy, + ctx->context_id, + &ctx->packed_prefix_nal_unit_data_buf_id[i], + 1); + CHECK_VASTATUS(va_status,"vaRenderPicture"); + + va_status = vaRenderPicture(ctx->va_dpy, + ctx->context_id, + &ctx->packed_slice_header_param_buf_id[i], + 1); + CHECK_VASTATUS(va_status,"vaRenderPicture"); + + va_status = vaRenderPicture(ctx->va_dpy, + ctx->context_id, + &ctx->packed_slice_header_data_buf_id[i], + 1); + CHECK_VASTATUS(va_status,"vaRenderPicture"); + + va_status = vaRenderPicture(ctx->va_dpy, + ctx->context_id, + &ctx->slice_param_buf_id[i], + 1); + CHECK_VASTATUS(va_status,"vaRenderPicture"); + } + + va_status = vaEndPicture(ctx->va_dpy, ctx->context_id); + CHECK_VASTATUS(va_status,"vaEndPicture"); + + svcenc_store_coded_buffer(ctx, current_surface); + + return 0; +} + +static int +svcenc_destroy_buffers(struct svcenc_context *ctx, + VABufferID *va_buffers, + unsigned int num_va_buffers) +{ + VAStatus va_status; + unsigned int i; + + for (i = 0; i < num_va_buffers; i++) { + if (va_buffers[i] != VA_INVALID_ID) { + va_status = vaDestroyBuffer(ctx->va_dpy, va_buffers[i]); + CHECK_VASTATUS(va_status,"vaDestroyBuffer"); + va_buffers[i] = VA_INVALID_ID; + } + } + + return 0; +} + +int +end_picture(struct svcenc_context *ctx, + svcenc_surface *current_surface) +{ + svcenc_destroy_buffers(ctx, &ctx->seq_param_buf_id, 1); + svcenc_destroy_buffers(ctx, &ctx->pic_param_buf_id, 1); + svcenc_destroy_buffers(ctx, &ctx->packed_sei_scalability_info_header_param_buf_id, 1); + svcenc_destroy_buffers(ctx, &ctx->packed_sei_scalability_info_buf_id, 1); + svcenc_destroy_buffers(ctx, &ctx->packed_seq_header_param_buf_id, 1); + svcenc_destroy_buffers(ctx, &ctx->packed_seq_buf_id, 1); + svcenc_destroy_buffers(ctx, &ctx->packed_svc_seq_header_param_buf_id, 1); + svcenc_destroy_buffers(ctx, &ctx->packed_svc_seq_buf_id, 1); + svcenc_destroy_buffers(ctx, &ctx->packed_pic_header_param_buf_id, 1); + svcenc_destroy_buffers(ctx, &ctx->packed_pic_buf_id, 1); + svcenc_destroy_buffers(ctx, &ctx->slice_param_buf_id[0], ctx->num_slices); + svcenc_destroy_buffers(ctx, &ctx->codedbuf_buf_id, 1); + svcenc_destroy_buffers(ctx, &ctx->misc_parameter_layer_structure_buf_id, 1); + svcenc_destroy_buffers(ctx, &ctx->misc_parameter_ratecontrol_buf_id[0], MAX_LAYERS); + svcenc_destroy_buffers(ctx, &ctx->misc_parameter_framerate_buf_id[0], MAX_LAYERS); + svcenc_destroy_buffers(ctx, &ctx->misc_parameter_hrd_buf_id, 1); + svcenc_destroy_buffers(ctx, &ctx->packed_sei_header_param_buf_id, 1); + svcenc_destroy_buffers(ctx, &ctx->packed_sei_buf_id, 1); + svcenc_destroy_buffers(ctx, &ctx->packed_slice_header_param_buf_id[0], ctx->num_slices); + svcenc_destroy_buffers(ctx, &ctx->packed_slice_header_data_buf_id[0], ctx->num_slices); + svcenc_destroy_buffers(ctx, &ctx->packed_prefix_nal_unit_param_buf_id[0], ctx->num_slices); + svcenc_destroy_buffers(ctx, &ctx->packed_prefix_nal_unit_data_buf_id[0], ctx->num_slices); + + memset(ctx->slice_param, 0, sizeof(ctx->slice_param)); + ctx->num_slices = 0; + + return 0; +} + +void +encode_picture(struct svcenc_context *ctx, svcenc_surface *current_surface) +{ + begin_picture(ctx, current_surface); + render_picture(ctx, current_surface); + end_picture(ctx, current_surface); + + svcenc_update_ref_frames(ctx, current_surface); + + if ((current_surface->is_idr) && + (ctx->rate_control_mode & VA_RC_CBR)) { + ctx->prev_idr_cpb_removal = ctx->current_idr_cpb_removal; + } +} + +static void +svcenc_va_init(struct svcenc_context *ctx) +{ + VAProfile *profile_list; + VAEntrypoint *entrypoint_list; + VAConfigAttrib attrib_list[4]; + VAStatus va_status; + int max_profiles, num_profiles = 0, profile = VAProfileNone; + int max_entrypoints, num_entrypoints = 0, entrypoint; + int major_ver, minor_ver; + int i, j; + + ctx->va_dpy = va_open_display(); + va_status = vaInitialize(ctx->va_dpy, + &major_ver, + &minor_ver); + CHECK_VASTATUS(va_status, "vaInitialize"); + + max_profiles = vaMaxNumProfiles(ctx->va_dpy); + profile_list = malloc(max_profiles * sizeof(VAProfile)); + vaQueryConfigProfiles(ctx->va_dpy, + profile_list, + &num_profiles); + + for (i = 0; i < ARRAY_ELEMS(g_va_profiles); i++) { + for (j = 0; j < num_profiles; j++) { + if (g_va_profiles[i] == profile_list[j]) { + profile = g_va_profiles[i]; + break; + } + } + + if (profile != VAProfileNone) + break; + } + + free(profile_list); + + if (profile == VAProfileNone) { + fprintf(stderr, "Can't find a supported profile\n"); + exit(-1); + } + + ctx->profile = profile; + + max_entrypoints = vaMaxNumEntrypoints(ctx->va_dpy); + entrypoint_list = malloc(max_entrypoints * sizeof(VAEntrypoint)); + vaQueryConfigEntrypoints(ctx->va_dpy, + ctx->profile, + entrypoint_list, + &num_entrypoints); + + for (entrypoint = 0; entrypoint < num_entrypoints; entrypoint++) { + if (entrypoint_list[entrypoint] == VAEntrypointEncSlice) + break; + } + + free(entrypoint_list); + + if (entrypoint == num_entrypoints) { + /* not find Slice entry point */ + fprintf(stderr, "Can't find the supported entrypoint\n"); + exit(-1); + } + + /* find out the format for the render target, and rate control mode */ + attrib_list[0].type = VAConfigAttribRTFormat; + attrib_list[1].type = VAConfigAttribRateControl; + attrib_list[2].type = VAConfigAttribEncPackedHeaders; + attrib_list[3].type = VAConfigAttribEncRateControlExt; + + vaGetConfigAttributes(ctx->va_dpy, + ctx->profile, + VAEntrypointEncSlice, + &attrib_list[0], + 4); + + if ((attrib_list[0].value & VA_RT_FORMAT_YUV420) == 0) { + /* not find desired YUV420 RT format */ + assert(0); + } + + if ((attrib_list[1].value & ctx->rate_control_mode) == 0) { + /* Can't find matched RC mode */ + fprintf(stderr, "RC mode %d isn't found, exit\n", ctx->rate_control_mode); + assert(0); + } + + if ((attrib_list[2].value & (VA_ENC_PACKED_HEADER_SEQUENCE | + VA_ENC_PACKED_HEADER_PICTURE | + VA_ENC_PACKED_HEADER_SLICE | + VA_ENC_PACKED_HEADER_RAW_DATA)) == 0) { + /* Can't find matched PACKED HEADER mode */ + assert(0); + } + + if (attrib_list[3].value == VA_ATTRIB_NOT_SUPPORTED) { + ctx->layer_brc = 0; // force to 0 + } else { + VAConfigAttribValEncRateControlExt *val = (VAConfigAttribValEncRateControlExt *)&attrib_list[3].value; + + if (!val->bits.max_num_temporal_layers_minus1) { + fprintf(stderr, "Do not support temporal layer\n"); + assert(0); + } + + if (ctx->hierarchical_levels > (val->bits.max_num_temporal_layers_minus1 + 1)) { + fprintf(stderr, "Over the maximum number of the supported layers\n"); + assert(0); + } + + if (!val->bits.temporal_layer_bitrate_control_flag) + ctx->layer_brc = 0; // force to 0 + } + + attrib_list[0].value = VA_RT_FORMAT_YUV420; /* set to desired RT format */ + attrib_list[1].value = ctx->rate_control_mode; /* set to desired RC mode */ + attrib_list[2].value = (VA_ENC_PACKED_HEADER_SEQUENCE | + VA_ENC_PACKED_HEADER_PICTURE | + VA_ENC_PACKED_HEADER_SLICE | + VA_ENC_PACKED_HEADER_RAW_DATA); + + va_status = vaCreateConfig(ctx->va_dpy, + ctx->profile, + VAEntrypointEncSlice, + attrib_list, + 3, + &ctx->config_id); + CHECK_VASTATUS(va_status, "vaCreateConfig"); + + /* Create a context for this decode pipe */ + va_status = vaCreateContext(ctx->va_dpy, + ctx->config_id, + ctx->width, + ctx->height, + VA_PROGRESSIVE, + 0, + 0, + &ctx->context_id); + CHECK_VASTATUS(va_status, "vaCreateContext"); + + va_status = vaCreateSurfaces(ctx->va_dpy, + VA_RT_FORMAT_YUV420, + ctx->width, + ctx->height, + src_surfaces, + NUM_SURFACES, + NULL, + 0); + CHECK_VASTATUS(va_status, "vaCreateSurfaces"); + + va_status = vaCreateSurfaces(ctx->va_dpy, + VA_RT_FORMAT_YUV420, + ctx->width, + ctx->height, + rec_surfaces, + NUM_SURFACES, + NULL, + 0); + CHECK_VASTATUS(va_status, "vaCreateSurfaces"); +} + +static void +svcenc_sei_init(struct svcenc_context *ctx) +{ + if (!(ctx->rate_control_mode & VA_RC_CBR)) + return; + + /* it comes for the bps defined in SPS */ + ctx->i_initial_cpb_removal_delay = 2 * 90000; + ctx->i_initial_cpb_removal_delay_offset = 2 * 90000; + + ctx->i_cpb_removal_delay = 2; + ctx->i_initial_cpb_removal_delay_length = 24; + ctx->i_cpb_removal_delay_length = 24; + ctx->i_dpb_output_delay_length = 24; + ctx->time_offset_length = 24; + + ctx->prev_idr_cpb_removal = ctx->i_initial_cpb_removal_delay / 90000; + ctx->current_idr_cpb_removal = ctx->prev_idr_cpb_removal; + ctx->current_cpb_removal = 0; + ctx->idr_frame_num = 0; +} + +static void +svcenc_init(struct svcenc_context *ctx) +{ + int i; + + ctx->frame_data_buffer = (unsigned char *)malloc(ctx->frame_size); + ctx->num_remainder_bframes = 0; + ctx->max_num_ref_frames = ctx->gop_size; + ctx->num_ref_frames = 0; + + switch (ctx->gop_size) { + case 1: + ctx->hierarchical_levels = 1; + break; + + case 2: + ctx->hierarchical_levels = 2; + break; + + case 4: + ctx->hierarchical_levels = 3; + break; + + case 8: + ctx->hierarchical_levels = 4; + break; + + default: + /* Never get here !!! */ + assert(0); + break; + } + + if (ctx->gop_type == 1) { // B + ctx->intra_period = 2 * ctx->gop_size; + ctx->ip_period = ctx->gop_size; + ctx->intra_idr_period = 0; // 0 means infinite + } else { + ctx->intra_period = 2 * ctx->gop_size; + ctx->ip_period = 1; + ctx->intra_idr_period = 8 * ctx->intra_period; + } + + ctx->framerate_per_100s = frame_rates[ctx->hierarchical_levels - 1] * 100; + + ctx->upload_task_header = NULL; + ctx->upload_task_tail = NULL; + + ctx->reordering_info[0] = ctx->reordering_info[1] = 0; + + ctx->seq_param_buf_id = VA_INVALID_ID; + ctx->pic_param_buf_id = VA_INVALID_ID; + ctx->packed_sei_scalability_info_header_param_buf_id = VA_INVALID_ID; + ctx->packed_sei_scalability_info_buf_id = VA_INVALID_ID; + ctx->packed_seq_header_param_buf_id = VA_INVALID_ID; + ctx->packed_seq_buf_id = VA_INVALID_ID; + ctx->packed_svc_seq_header_param_buf_id = VA_INVALID_ID; + ctx->packed_svc_seq_buf_id = VA_INVALID_ID; + ctx->packed_pic_header_param_buf_id = VA_INVALID_ID; + ctx->packed_pic_buf_id = VA_INVALID_ID; + ctx->codedbuf_buf_id = VA_INVALID_ID; + ctx->misc_parameter_layer_structure_buf_id = VA_INVALID_ID; + + for (i = 0; i < MAX_LAYERS; i++) { + ctx->misc_parameter_ratecontrol_buf_id[i] = VA_INVALID_ID; + ctx->misc_parameter_framerate_buf_id[i] = VA_INVALID_ID; + } + + ctx->misc_parameter_hrd_buf_id = VA_INVALID_ID; + ctx->packed_sei_header_param_buf_id = VA_INVALID_ID; + ctx->packed_sei_buf_id = VA_INVALID_ID; + + for (i = 0; i < MAX_SLICES; i++) { + ctx->packed_slice_header_param_buf_id[i] = VA_INVALID_ID; + ctx->packed_slice_header_data_buf_id[i] = VA_INVALID_ID; + ctx->packed_prefix_nal_unit_param_buf_id[i] = VA_INVALID_ID; + ctx->packed_prefix_nal_unit_data_buf_id[i] = VA_INVALID_ID; + } + + svcenc_va_init(ctx); + + /* update the next surface status */ + ctx->next_svcenc_surface.slot_in_surfaces = 0; + ctx->next_svcenc_surface.coding_order = 0; + ctx->next_svcenc_surface.display_order = 0; + ctx->next_svcenc_surface.temporal_id = 0; + ctx->next_svcenc_surface.frame_num = 0; + ctx->next_svcenc_surface.poc = 0; + ctx->next_svcenc_surface.picture_type = VAEncPictureTypeIntra; + ctx->next_svcenc_surface.is_intra = 1; + ctx->next_svcenc_surface.is_idr = 1; + ctx->next_svcenc_surface.is_ref = 1; + ctx->next_svcenc_surface.rec_surface = rec_surfaces[ctx->next_svcenc_surface.slot_in_surfaces]; + memset(src_surface_status, SRC_SURFACE_IN_STORAGE, sizeof(src_surface_status)); + + svcenc_sei_init(ctx); +} + +static void +svcenc_run(struct svcenc_context *ctx) +{ + int coding_order = 0; + svcenc_surface current_surface; + + pthread_create(&ctx->upload_thread, NULL, upload_task_thread, ctx); + current_surface = ctx->next_svcenc_surface; + upload_task_queue(ctx, current_surface.display_order, current_surface.slot_in_surfaces); + + while (coding_order < ctx->num_pictures) { + if (coding_order < (ctx->num_pictures - 1)) { + if (ctx->gop_type == 1) { + update_next_picture_info(ctx); + } else { + update_next_picture_info_pgop(ctx); + } + + assert(current_surface.display_order != ctx->next_svcenc_surface.display_order); + upload_task_queue(ctx, ctx->next_svcenc_surface.display_order, ctx->next_svcenc_surface.slot_in_surfaces); + } + + while (src_surface_status[current_surface.slot_in_surfaces] != SRC_SURFACE_IN_ENCODING) + usleep(1); + + encode_picture(ctx, ¤t_surface); + + if (coding_order < (ctx->num_pictures - 1)) + current_surface = ctx->next_svcenc_surface; + + coding_order++; + fprintf(stderr, "\r %d/%d ...", coding_order, ctx->num_pictures); + fflush(stdout); + } + + pthread_join(ctx->upload_thread, NULL); +} + +static void +svcenc_va_end(struct svcenc_context *ctx) +{ + vaDestroySurfaces(ctx->va_dpy, src_surfaces, NUM_SURFACES); + vaDestroySurfaces(ctx->va_dpy, rec_surfaces, NUM_SURFACES); + + vaDestroyContext(ctx->va_dpy, ctx->context_id); + vaDestroyConfig(ctx->va_dpy, ctx->config_id); + vaTerminate(ctx->va_dpy); + va_close_display(ctx->va_dpy); +} + +static void +svcenc_end(struct svcenc_context *ctx) +{ + free(ctx->frame_data_buffer); + ctx->frame_data_buffer = NULL; + svcenc_va_end(ctx); +} + +int +main(int argc, char *argv[]) +{ + struct svcenc_context ctx; + struct timeval tpstart, tpend; + float timeuse; + + gettimeofday(&tpstart, NULL); + + memset(&ctx, 0, sizeof(ctx)); + parse_args(&ctx, argc, argv); + + svcenc_init(&ctx); + svcenc_run(&ctx); + svcenc_end(&ctx); + + gettimeofday(&tpend, NULL); + timeuse = 1000000 * (tpend.tv_sec - tpstart.tv_sec) + tpend.tv_usec - tpstart.tv_usec; + timeuse /= 1000000; + fprintf(stderr, "\ndone!\n"); + fprintf(stderr, "encode %d frames in %f secondes, FPS is %.1f\n", ctx.num_pictures, timeuse, ctx.num_pictures / timeuse); + + svcenc_exit(&ctx, 0); + + return 0; +} diff --git a/va/wayland/wayland-drm-client-protocol.h b/va/wayland/wayland-drm-client-protocol.h index cba188e..7f2789b 100644 --- a/va/wayland/wayland-drm-client-protocol.h +++ b/va/wayland/wayland-drm-client-protocol.h @@ -1,7 +1,26 @@ -/* +/* Generated by wayland-scanner 1.11.90 */ + +#ifndef DRM_CLIENT_PROTOCOL_H +#define DRM_CLIENT_PROTOCOL_H + +#include <stdint.h> +#include <stddef.h> +#include "wayland-client.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * @page page_drm The drm protocol + * @section page_ifaces_drm Interfaces + * - @subpage page_iface_wl_drm - + * @section page_copyright_drm Copyright + * <pre> + * * Copyright © 2008-2011 Kristian Høgsberg * Copyright © 2010-2011 Intel Corporation - * + * * Permission to use, copy, modify, distribute, and sell this * software and its documentation for any purpose is hereby granted * without fee, provided that\n the above copyright notice appear in @@ -13,7 +32,7 @@ * representations about the suitability of this software for any * purpose. It is provided "as is" without express or implied * warranty. - * + * * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND * FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY @@ -22,24 +41,19 @@ * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, * ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF * THIS SOFTWARE. + * </pre> */ - -#ifndef DRM_CLIENT_PROTOCOL_H -#define DRM_CLIENT_PROTOCOL_H - -#ifdef __cplusplus -extern "C" { -#endif - -#include <stdint.h> -#include <stddef.h> -#include "wayland-client.h" - -struct wl_client; -struct wl_resource; - +struct wl_buffer; struct wl_drm; +/** + * @page page_iface_wl_drm wl_drm + * @section page_iface_wl_drm_api API + * See @ref iface_wl_drm. + */ +/** + * @defgroup iface_wl_drm The wl_drm interface + */ extern const struct wl_interface wl_drm_interface; #ifndef WL_DRM_ERROR_ENUM @@ -115,28 +129,30 @@ enum wl_drm_format { }; #endif /* WL_DRM_FORMAT_ENUM */ +/** + * @ingroup iface_wl_drm + * @struct wl_drm_listener + */ struct wl_drm_listener { /** - * device - device - * @name: name */ void (*device)(void *data, struct wl_drm *wl_drm, const char *name); /** - * format - format - * @format: format */ void (*format)(void *data, struct wl_drm *wl_drm, uint32_t format); /** - * authenticated - authenticated */ void (*authenticated)(void *data, struct wl_drm *wl_drm); }; +/** + * @ingroup wl_drm_iface + */ static inline int wl_drm_add_listener(struct wl_drm *wl_drm, const struct wl_drm_listener *listener, void *data) @@ -145,28 +161,53 @@ wl_drm_add_listener(struct wl_drm *wl_drm, (void (**)(void)) listener, data); } -#define WL_DRM_AUTHENTICATE 0 -#define WL_DRM_CREATE_BUFFER 1 -#define WL_DRM_CREATE_PLANAR_BUFFER 2 +#define WL_DRM_AUTHENTICATE 0 +#define WL_DRM_CREATE_BUFFER 1 +#define WL_DRM_CREATE_PLANAR_BUFFER 2 + +/** + * @ingroup iface_wl_drm + */ +#define WL_DRM_AUTHENTICATE_SINCE_VERSION 1 +/** + * @ingroup iface_wl_drm + */ +#define WL_DRM_CREATE_BUFFER_SINCE_VERSION 1 +/** + * @ingroup iface_wl_drm + */ +#define WL_DRM_CREATE_PLANAR_BUFFER_SINCE_VERSION 1 +/** @ingroup iface_wl_drm */ static inline void wl_drm_set_user_data(struct wl_drm *wl_drm, void *user_data) { wl_proxy_set_user_data((struct wl_proxy *) wl_drm, user_data); } +/** @ingroup iface_wl_drm */ static inline void * wl_drm_get_user_data(struct wl_drm *wl_drm) { return wl_proxy_get_user_data((struct wl_proxy *) wl_drm); } +static inline uint32_t +wl_drm_get_version(struct wl_drm *wl_drm) +{ + return wl_proxy_get_version((struct wl_proxy *) wl_drm); +} + +/** @ingroup iface_wl_drm */ static inline void wl_drm_destroy(struct wl_drm *wl_drm) { wl_proxy_destroy((struct wl_proxy *) wl_drm); } +/** + * @ingroup iface_wl_drm + */ static inline void wl_drm_authenticate(struct wl_drm *wl_drm, uint32_t id) { @@ -174,34 +215,30 @@ wl_drm_authenticate(struct wl_drm *wl_drm, uint32_t id) WL_DRM_AUTHENTICATE, id); } +/** + * @ingroup iface_wl_drm + */ static inline struct wl_buffer * wl_drm_create_buffer(struct wl_drm *wl_drm, uint32_t name, int32_t width, int32_t height, uint32_t stride, uint32_t format) { struct wl_proxy *id; - id = wl_proxy_create((struct wl_proxy *) wl_drm, - &wl_buffer_interface); - if (!id) - return NULL; - - wl_proxy_marshal((struct wl_proxy *) wl_drm, - WL_DRM_CREATE_BUFFER, id, name, width, height, stride, format); + id = wl_proxy_marshal_constructor((struct wl_proxy *) wl_drm, + WL_DRM_CREATE_BUFFER, &wl_buffer_interface, NULL, name, width, height, stride, format); return (struct wl_buffer *) id; } +/** + * @ingroup iface_wl_drm + */ static inline struct wl_buffer * wl_drm_create_planar_buffer(struct wl_drm *wl_drm, uint32_t name, int32_t width, int32_t height, uint32_t format, int32_t offset0, int32_t stride0, int32_t offset1, int32_t stride1, int32_t offset2, int32_t stride2) { struct wl_proxy *id; - id = wl_proxy_create((struct wl_proxy *) wl_drm, - &wl_buffer_interface); - if (!id) - return NULL; - - wl_proxy_marshal((struct wl_proxy *) wl_drm, - WL_DRM_CREATE_PLANAR_BUFFER, id, name, width, height, format, offset0, stride0, offset1, stride1, offset2, stride2); + id = wl_proxy_marshal_constructor((struct wl_proxy *) wl_drm, + WL_DRM_CREATE_PLANAR_BUFFER, &wl_buffer_interface, NULL, name, width, height, format, offset0, stride0, offset1, stride1, offset2, stride2); return (struct wl_buffer *) id; } |