Google Git
Sign in
fuchsia / third_party / github.com / intel / libva-utils / cacd9adade86f998163c5694b93082d0cbfd180c / . / encode / svctenc.c
blob: cf5b3b56c0604d04cfa713441746be315c7b3681 [file] [log] [blame]
/*
* 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 <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,
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));
assert(bs->buffer);
}
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[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[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));
assert(task);
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->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;
}
}
assert(found != -1);
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;
memset(RefPicList0, 0, sizeof(RefPicList0));
memset(RefPicList1, 0, sizeof(RefPicList1));
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 = 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_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:
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;
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));
assert(profile_list);
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));
assert(entrypoint_list);
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, &current_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;
}