--- /dev/null
+/*
+ * 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;
+}
OSDN Git Service
