2014-06-03 12:47:49 +00:00
|
|
|
/*****************************************************************************
|
|
|
|
* This file is part of Kvazaar HEVC encoder.
|
|
|
|
*
|
2015-02-23 11:18:48 +00:00
|
|
|
* Copyright (C) 2013-2015 Tampere University of Technology and others (see
|
2014-06-03 12:47:49 +00:00
|
|
|
* COPYING file).
|
|
|
|
*
|
2015-02-23 11:18:48 +00:00
|
|
|
* Kvazaar is free software: you can redistribute it and/or modify it under
|
|
|
|
* the terms of the GNU Lesser General Public License as published by the
|
|
|
|
* Free Software Foundation; either version 2.1 of the License, or (at your
|
|
|
|
* option) any later version.
|
2014-06-03 12:47:49 +00:00
|
|
|
*
|
2015-02-23 11:18:48 +00:00
|
|
|
* Kvazaar is distributed in the hope that it will be useful, but WITHOUT ANY
|
|
|
|
* WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
|
|
|
|
* FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for
|
|
|
|
* more details.
|
2014-06-03 12:47:49 +00:00
|
|
|
*
|
2015-02-23 11:18:48 +00:00
|
|
|
* You should have received a copy of the GNU General Public License along
|
|
|
|
* with Kvazaar. If not, see <http://www.gnu.org/licenses/>.
|
2014-06-03 12:47:49 +00:00
|
|
|
****************************************************************************/
|
|
|
|
|
2014-06-04 14:45:46 +00:00
|
|
|
#include "encoder_state-bitstream.h"
|
|
|
|
|
2016-04-01 14:14:23 +00:00
|
|
|
#include <stdio.h>
|
2015-03-26 08:40:21 +00:00
|
|
|
#include <stdlib.h>
|
2016-04-01 14:14:23 +00:00
|
|
|
#include <string.h>
|
2014-06-04 15:00:50 +00:00
|
|
|
|
2016-04-01 14:14:23 +00:00
|
|
|
#include "bitstream.h"
|
|
|
|
#include "cabac.h"
|
2014-06-12 04:33:27 +00:00
|
|
|
#include "checkpoint.h"
|
2016-04-01 14:14:23 +00:00
|
|
|
#include "cu.h"
|
|
|
|
#include "encoder.h"
|
|
|
|
#include "encoder_state-geometry.h"
|
2014-06-04 14:45:46 +00:00
|
|
|
#include "encoderstate.h"
|
2016-04-01 14:14:23 +00:00
|
|
|
#include "imagelist.h"
|
|
|
|
#include "kvazaar.h"
|
2016-03-10 13:28:31 +00:00
|
|
|
#include "kvz_math.h"
|
2014-06-04 14:45:46 +00:00
|
|
|
#include "nal.h"
|
2016-04-01 14:14:23 +00:00
|
|
|
#include "scalinglist.h"
|
|
|
|
#include "tables.h"
|
|
|
|
#include "threadqueue.h"
|
|
|
|
#include "videoframe.h"
|
2014-06-04 14:45:46 +00:00
|
|
|
|
2014-06-03 12:47:49 +00:00
|
|
|
|
2015-08-27 12:08:06 +00:00
|
|
|
static void encoder_state_write_bitstream_aud(encoder_state_t * const state)
|
2014-06-03 12:47:49 +00:00
|
|
|
{
|
2015-03-04 15:00:23 +00:00
|
|
|
bitstream_t * const stream = &state->stream;
|
2015-09-15 07:19:31 +00:00
|
|
|
kvz_nal_write(stream, KVZ_NAL_AUD_NUT, 0, 1);
|
2015-08-27 12:08:06 +00:00
|
|
|
|
2016-08-10 00:46:23 +00:00
|
|
|
uint8_t pic_type = state->frame->slicetype == KVZ_SLICE_I ? 0
|
|
|
|
: state->frame->slicetype == KVZ_SLICE_P ? 1
|
2015-08-27 12:08:06 +00:00
|
|
|
: 2;
|
2014-06-03 12:47:49 +00:00
|
|
|
WRITE_U(stream, pic_type, 3, "pic_type");
|
|
|
|
|
2015-08-27 11:33:30 +00:00
|
|
|
kvz_bitstream_add_rbsp_trailing_bits(stream);
|
2014-06-03 12:47:49 +00:00
|
|
|
}
|
|
|
|
|
2015-10-14 09:33:07 +00:00
|
|
|
static void encoder_state_write_bitstream_PTL(bitstream_t *stream,
|
|
|
|
encoder_state_t * const state)
|
2014-06-03 12:47:49 +00:00
|
|
|
{
|
|
|
|
// PTL
|
|
|
|
// Profile Tier
|
|
|
|
WRITE_U(stream, 0, 2, "general_profile_space");
|
2018-05-28 08:31:05 +00:00
|
|
|
WRITE_U(stream, state->encoder_control->cfg.high_tier, 1, "general_tier_flag");
|
2015-04-29 12:10:37 +00:00
|
|
|
// Main Profile == 1, Main 10 profile == 2
|
2018-07-25 09:24:17 +00:00
|
|
|
WRITE_U(stream, 6, 5, "general_profile_idc");
|
2014-06-03 12:47:49 +00:00
|
|
|
/* Compatibility flags should be set at general_profile_idc
|
|
|
|
* (so with general_profile_idc = 1, compatibility_flag[1] should be 1)
|
|
|
|
* According to specification, when compatibility_flag[1] is set,
|
|
|
|
* compatibility_flag[2] should be set too.
|
|
|
|
*/
|
|
|
|
WRITE_U(stream, 3<<29, 32, "general_profile_compatibility_flag[]");
|
|
|
|
|
|
|
|
WRITE_U(stream, 1, 1, "general_progressive_source_flag");
|
2015-04-08 14:17:45 +00:00
|
|
|
WRITE_U(stream, state->encoder_control->in.source_scan_type!= 0, 1, "general_interlaced_source_flag");
|
2014-06-03 12:47:49 +00:00
|
|
|
WRITE_U(stream, 0, 1, "general_non_packed_constraint_flag");
|
|
|
|
WRITE_U(stream, 0, 1, "general_frame_only_constraint_flag");
|
|
|
|
|
|
|
|
WRITE_U(stream, 0, 32, "XXX_reserved_zero_44bits[0..31]");
|
|
|
|
WRITE_U(stream, 0, 12, "XXX_reserved_zero_44bits[32..43]");
|
|
|
|
|
|
|
|
// end Profile Tier
|
|
|
|
|
2017-11-08 14:15:41 +00:00
|
|
|
uint8_t level = state->encoder_control->cfg.level;
|
|
|
|
WRITE_U(stream, level * 3, 8, "general_level_idc");
|
2014-06-03 12:47:49 +00:00
|
|
|
|
|
|
|
WRITE_U(stream, 0, 1, "sub_layer_profile_present_flag");
|
|
|
|
WRITE_U(stream, 0, 1, "sub_layer_level_present_flag");
|
|
|
|
|
2015-10-14 09:33:07 +00:00
|
|
|
for (int i = 1; i < 8; i++) {
|
2014-06-03 12:47:49 +00:00
|
|
|
WRITE_U(stream, 0, 2, "reserved_zero_2bits");
|
|
|
|
}
|
|
|
|
|
|
|
|
// end PTL
|
|
|
|
}
|
|
|
|
|
2018-07-25 08:02:09 +00:00
|
|
|
/*
|
2015-10-14 09:33:07 +00:00
|
|
|
static void encoder_state_write_bitstream_vid_parameter_set(bitstream_t* stream,
|
|
|
|
encoder_state_t * const state)
|
2014-06-03 12:47:49 +00:00
|
|
|
{
|
2015-09-14 09:43:28 +00:00
|
|
|
#ifdef KVZ_DEBUG
|
2014-06-03 12:47:49 +00:00
|
|
|
printf("=========== Video Parameter Set ID: 0 ===========\n");
|
|
|
|
#endif
|
|
|
|
|
|
|
|
WRITE_U(stream, 0, 4, "vps_video_parameter_set_id");
|
|
|
|
WRITE_U(stream, 3, 2, "vps_reserved_three_2bits" );
|
|
|
|
WRITE_U(stream, 0, 6, "vps_reserved_zero_6bits" );
|
|
|
|
WRITE_U(stream, 1, 3, "vps_max_sub_layers_minus1");
|
|
|
|
WRITE_U(stream, 0, 1, "vps_temporal_id_nesting_flag");
|
|
|
|
WRITE_U(stream, 0xffff, 16, "vps_reserved_ffff_16bits");
|
|
|
|
|
2015-10-14 09:33:07 +00:00
|
|
|
encoder_state_write_bitstream_PTL(stream, state);
|
2014-06-03 12:47:49 +00:00
|
|
|
|
|
|
|
WRITE_U(stream, 0, 1, "vps_sub_layer_ordering_info_present_flag");
|
|
|
|
|
|
|
|
//for each layer
|
2015-10-14 09:33:07 +00:00
|
|
|
for (int i = 0; i < 1; i++) {
|
2014-06-03 12:47:49 +00:00
|
|
|
WRITE_UE(stream, 1, "vps_max_dec_pic_buffering");
|
|
|
|
WRITE_UE(stream, 0, "vps_num_reorder_pics");
|
|
|
|
WRITE_UE(stream, 0, "vps_max_latency_increase");
|
|
|
|
}
|
|
|
|
|
|
|
|
WRITE_U(stream, 0, 6, "vps_max_nuh_reserved_zero_layer_id");
|
|
|
|
WRITE_UE(stream, 0, "vps_max_op_sets_minus1");
|
|
|
|
WRITE_U(stream, 0, 1, "vps_timing_info_present_flag");
|
|
|
|
|
|
|
|
//IF timing info
|
|
|
|
//END IF
|
|
|
|
|
|
|
|
WRITE_U(stream, 0, 1, "vps_extension_flag");
|
2015-08-27 12:05:44 +00:00
|
|
|
|
|
|
|
kvz_bitstream_add_rbsp_trailing_bits(stream);
|
2014-06-03 12:47:49 +00:00
|
|
|
}
|
|
|
|
|
2015-10-14 09:33:07 +00:00
|
|
|
static void encoder_state_write_bitstream_scaling_list(bitstream_t *stream,
|
|
|
|
encoder_state_t * const state)
|
2014-06-03 12:47:49 +00:00
|
|
|
{
|
2015-03-04 15:00:23 +00:00
|
|
|
const encoder_control_t * const encoder = state->encoder_control;
|
2014-06-03 12:47:49 +00:00
|
|
|
uint32_t size_id;
|
|
|
|
for (size_id = 0; size_id < SCALING_LIST_SIZE_NUM; size_id++) {
|
|
|
|
int32_t list_id;
|
2015-08-26 08:50:27 +00:00
|
|
|
for (list_id = 0; list_id < kvz_g_scaling_list_num[size_id]; list_id++) {
|
2014-06-03 12:47:49 +00:00
|
|
|
uint8_t scaling_list_pred_mode_flag = 1;
|
|
|
|
int32_t pred_list_idx;
|
|
|
|
int32_t i;
|
|
|
|
uint32_t ref_matrix_id = UINT32_MAX;
|
|
|
|
|
|
|
|
for (pred_list_idx = list_id; pred_list_idx >= 0; pred_list_idx--) {
|
|
|
|
const int32_t * const pred_list = (list_id == pred_list_idx) ?
|
2015-08-26 08:50:27 +00:00
|
|
|
kvz_scalinglist_get_default(size_id, pred_list_idx) :
|
2014-06-03 12:47:49 +00:00
|
|
|
encoder->scaling_list.scaling_list_coeff[size_id][pred_list_idx];
|
|
|
|
|
2015-08-26 08:50:27 +00:00
|
|
|
if (!memcmp(encoder->scaling_list.scaling_list_coeff[size_id][list_id], pred_list, sizeof(int32_t) * MIN(8, kvz_g_scaling_list_size[size_id])) &&
|
2014-06-03 12:47:49 +00:00
|
|
|
((size_id < SCALING_LIST_16x16) ||
|
|
|
|
(encoder->scaling_list.scaling_list_dc[size_id][list_id] == encoder->scaling_list.scaling_list_dc[size_id][pred_list_idx]))) {
|
|
|
|
ref_matrix_id = pred_list_idx;
|
|
|
|
scaling_list_pred_mode_flag = 0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
WRITE_U(stream, scaling_list_pred_mode_flag, 1, "scaling_list_pred_mode_flag" );
|
|
|
|
|
|
|
|
if (!scaling_list_pred_mode_flag) {
|
|
|
|
WRITE_UE(stream, list_id - ref_matrix_id, "scaling_list_pred_matrix_id_delta");
|
|
|
|
} else {
|
|
|
|
int32_t delta;
|
2015-08-26 08:50:27 +00:00
|
|
|
const int32_t coef_num = MIN(MAX_MATRIX_COEF_NUM, kvz_g_scaling_list_size[size_id]);
|
2014-06-03 12:47:49 +00:00
|
|
|
const uint32_t * const scan_cg = (size_id == 0) ? g_sig_last_scan_16x16 : g_sig_last_scan_32x32;
|
|
|
|
int32_t next_coef = 8;
|
|
|
|
const int32_t * const coef_list = encoder->scaling_list.scaling_list_coeff[size_id][list_id];
|
|
|
|
|
|
|
|
if (size_id >= SCALING_LIST_16x16) {
|
|
|
|
WRITE_SE(stream, encoder->scaling_list.scaling_list_dc[size_id][list_id] - 8, "scaling_list_dc_coef_minus8");
|
|
|
|
next_coef = encoder->scaling_list.scaling_list_dc[size_id][list_id];
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; i < coef_num; i++) {
|
|
|
|
delta = coef_list[scan_cg[i]] - next_coef;
|
|
|
|
next_coef = coef_list[scan_cg[i]];
|
|
|
|
if (delta > 127)
|
|
|
|
delta -= 256;
|
|
|
|
if (delta < -128)
|
|
|
|
delta += 256;
|
|
|
|
|
|
|
|
WRITE_SE(stream, delta, "scaling_list_delta_coef");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2018-07-25 08:02:09 +00:00
|
|
|
*/
|
2014-06-03 12:47:49 +00:00
|
|
|
|
2015-10-14 09:33:07 +00:00
|
|
|
static void encoder_state_write_bitstream_VUI(bitstream_t *stream,
|
|
|
|
encoder_state_t * const state)
|
2014-06-03 12:47:49 +00:00
|
|
|
{
|
2015-03-04 15:00:23 +00:00
|
|
|
const encoder_control_t * const encoder = state->encoder_control;
|
2015-09-14 09:43:28 +00:00
|
|
|
#ifdef KVZ_DEBUG
|
2014-06-03 12:47:49 +00:00
|
|
|
printf("=========== VUI Set ID: 0 ===========\n");
|
|
|
|
#endif
|
2017-02-06 11:00:25 +00:00
|
|
|
if (encoder->cfg.vui.sar_width > 0 && encoder->cfg.vui.sar_height > 0) {
|
2014-06-03 12:47:49 +00:00
|
|
|
int i;
|
|
|
|
static const struct
|
|
|
|
{
|
|
|
|
uint8_t width;
|
|
|
|
uint8_t height;
|
|
|
|
uint8_t idc;
|
|
|
|
} sar[] = {
|
|
|
|
// aspect_ratio_idc = 0 -> unspecified
|
|
|
|
{ 1, 1, 1 }, { 12, 11, 2 }, { 10, 11, 3 }, { 16, 11, 4 },
|
|
|
|
{ 40, 33, 5 }, { 24, 11, 6 }, { 20, 11, 7 }, { 32, 11, 8 },
|
|
|
|
{ 80, 33, 9 }, { 18, 11, 10}, { 15, 11, 11}, { 64, 33, 12},
|
|
|
|
{160, 99, 13}, { 4, 3, 14}, { 3, 2, 15}, { 2, 1, 16},
|
|
|
|
// aspect_ratio_idc = [17..254] -> reserved
|
|
|
|
{ 0, 0, 255 }
|
|
|
|
};
|
|
|
|
|
|
|
|
for (i = 0; sar[i].idc != 255; i++)
|
2017-02-06 11:00:25 +00:00
|
|
|
if (sar[i].width == encoder->cfg.vui.sar_width &&
|
|
|
|
sar[i].height == encoder->cfg.vui.sar_height)
|
2014-06-03 12:47:49 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
WRITE_U(stream, 1, 1, "aspect_ratio_info_present_flag");
|
|
|
|
WRITE_U(stream, sar[i].idc, 8, "aspect_ratio_idc");
|
|
|
|
if (sar[i].idc == 255) {
|
|
|
|
// EXTENDED_SAR
|
2017-02-06 11:00:25 +00:00
|
|
|
WRITE_U(stream, encoder->cfg.vui.sar_width, 16, "sar_width");
|
|
|
|
WRITE_U(stream, encoder->cfg.vui.sar_height, 16, "sar_height");
|
2014-06-03 12:47:49 +00:00
|
|
|
}
|
|
|
|
} else
|
|
|
|
WRITE_U(stream, 0, 1, "aspect_ratio_info_present_flag");
|
|
|
|
|
|
|
|
//IF aspect ratio info
|
|
|
|
//ENDIF
|
|
|
|
|
2017-02-06 11:00:25 +00:00
|
|
|
if (encoder->cfg.vui.overscan > 0) {
|
2014-06-03 12:47:49 +00:00
|
|
|
WRITE_U(stream, 1, 1, "overscan_info_present_flag");
|
2017-02-06 11:00:25 +00:00
|
|
|
WRITE_U(stream, encoder->cfg.vui.overscan - 1, 1, "overscan_appropriate_flag");
|
2014-06-03 12:47:49 +00:00
|
|
|
} else
|
|
|
|
WRITE_U(stream, 0, 1, "overscan_info_present_flag");
|
|
|
|
|
|
|
|
//IF overscan info
|
|
|
|
//ENDIF
|
|
|
|
|
2017-02-06 11:00:25 +00:00
|
|
|
if (encoder->cfg.vui.videoformat != 5 ||
|
|
|
|
encoder->cfg.vui.fullrange != 0 ||
|
|
|
|
encoder->cfg.vui.colorprim != 2 ||
|
|
|
|
encoder->cfg.vui.transfer != 2 ||
|
|
|
|
encoder->cfg.vui.colormatrix != 2) {
|
2014-06-03 12:47:49 +00:00
|
|
|
WRITE_U(stream, 1, 1, "video_signal_type_present_flag");
|
2017-02-06 11:00:25 +00:00
|
|
|
WRITE_U(stream, encoder->cfg.vui.videoformat, 3, "chroma_format");
|
|
|
|
WRITE_U(stream, encoder->cfg.vui.fullrange, 1, "video_full_range_flag");
|
2014-06-03 12:47:49 +00:00
|
|
|
|
2017-02-06 11:00:25 +00:00
|
|
|
if (encoder->cfg.vui.colorprim != 2 ||
|
|
|
|
encoder->cfg.vui.transfer != 2 ||
|
|
|
|
encoder->cfg.vui.colormatrix != 2) {
|
2014-06-03 12:47:49 +00:00
|
|
|
WRITE_U(stream, 1, 1, "colour_description_present_flag");
|
2017-02-06 11:00:25 +00:00
|
|
|
WRITE_U(stream, encoder->cfg.vui.colorprim, 8, "colour_primaries");
|
|
|
|
WRITE_U(stream, encoder->cfg.vui.transfer, 8, "transfer_characteristics");
|
|
|
|
WRITE_U(stream, encoder->cfg.vui.colormatrix, 8, "matrix_coeffs");
|
2014-06-03 12:47:49 +00:00
|
|
|
} else
|
|
|
|
WRITE_U(stream, 0, 1, "colour_description_present_flag");
|
|
|
|
} else
|
|
|
|
WRITE_U(stream, 0, 1, "video_signal_type_present_flag");
|
|
|
|
|
|
|
|
//IF video type
|
|
|
|
//ENDIF
|
|
|
|
|
2017-02-06 11:00:25 +00:00
|
|
|
if (encoder->cfg.vui.chroma_loc > 0) {
|
2014-06-03 12:47:49 +00:00
|
|
|
WRITE_U(stream, 1, 1, "chroma_loc_info_present_flag");
|
2017-02-06 11:00:25 +00:00
|
|
|
WRITE_UE(stream, encoder->cfg.vui.chroma_loc, "chroma_sample_loc_type_top_field");
|
|
|
|
WRITE_UE(stream, encoder->cfg.vui.chroma_loc, "chroma_sample_loc_type_bottom_field");
|
2014-06-03 12:47:49 +00:00
|
|
|
} else
|
|
|
|
WRITE_U(stream, 0, 1, "chroma_loc_info_present_flag");
|
|
|
|
|
|
|
|
//IF chroma loc info
|
|
|
|
//ENDIF
|
|
|
|
|
|
|
|
WRITE_U(stream, 0, 1, "neutral_chroma_indication_flag");
|
2015-10-14 09:32:38 +00:00
|
|
|
WRITE_U(stream, encoder->vui.field_seq_flag, 1, "field_seq_flag"); // 0: frames, 1: fields
|
|
|
|
WRITE_U(stream, encoder->vui.frame_field_info_present_flag, 1, "frame_field_info_present_flag");
|
2014-06-03 12:47:49 +00:00
|
|
|
WRITE_U(stream, 0, 1, "default_display_window_flag");
|
|
|
|
|
|
|
|
//IF default display window
|
|
|
|
//ENDIF
|
|
|
|
|
2016-01-14 09:48:35 +00:00
|
|
|
WRITE_U(stream, encoder->vui.timing_info_present_flag, 1, "vui_timing_info_present_flag");
|
|
|
|
if (encoder->vui.timing_info_present_flag) {
|
|
|
|
WRITE_U(stream, encoder->vui.num_units_in_tick, 32, "vui_num_units_in_tick");
|
|
|
|
WRITE_U(stream, encoder->vui.time_scale, 32, "vui_time_scale");
|
2014-06-03 12:47:49 +00:00
|
|
|
|
2016-01-14 09:48:35 +00:00
|
|
|
WRITE_U(stream, 0, 1, "vui_poc_proportional_to_timing_flag");
|
|
|
|
WRITE_U(stream, 0, 1, "vui_hrd_parameters_present_flag");
|
|
|
|
}
|
|
|
|
|
2014-06-03 12:47:49 +00:00
|
|
|
WRITE_U(stream, 0, 1, "bitstream_restriction_flag");
|
|
|
|
|
|
|
|
//IF bitstream restriction
|
|
|
|
//ENDIF
|
|
|
|
}
|
|
|
|
|
2016-08-03 05:18:56 +00:00
|
|
|
|
|
|
|
static void encoder_state_write_bitstream_SPS_extension(bitstream_t *stream,
|
|
|
|
encoder_state_t * const state)
|
|
|
|
{
|
2017-02-05 09:59:21 +00:00
|
|
|
const kvz_config *cfg = &state->encoder_control->cfg;
|
2018-07-25 09:24:17 +00:00
|
|
|
//if (cfg->implicit_rdpcm && cfg->lossless) {
|
2016-08-03 05:18:56 +00:00
|
|
|
WRITE_U(stream, 1, 1, "sps_extension_present_flag");
|
|
|
|
|
|
|
|
WRITE_U(stream, 1, 1, "sps_range_extension_flag");
|
|
|
|
WRITE_U(stream, 0, 1, "sps_multilayer_extension_flag");
|
|
|
|
WRITE_U(stream, 0, 1, "sps_3d_extension_flag");
|
2018-07-25 07:05:11 +00:00
|
|
|
WRITE_U(stream, 1, 1, "sps_next_extension_flag");
|
|
|
|
WRITE_U(stream, 0, 4, "sps_extension_4bits");
|
2016-08-03 05:18:56 +00:00
|
|
|
|
2018-07-25 09:24:17 +00:00
|
|
|
// Range Extension
|
2016-08-03 05:18:56 +00:00
|
|
|
WRITE_U(stream, 0, 1, "transform_skip_rotation_enabled_flag");
|
|
|
|
WRITE_U(stream, 0, 1, "transform_skip_context_enabled_flag");
|
|
|
|
WRITE_U(stream, 1, 1, "implicit_rdpcm_enabled_flag");
|
|
|
|
WRITE_U(stream, 0, 1, "explicit_rdpcm_enabled_flag");
|
|
|
|
WRITE_U(stream, 0, 1, "extended_precision_processing_flag");
|
|
|
|
WRITE_U(stream, 0, 1, "intra_smoothing_disabled_flag");
|
|
|
|
WRITE_U(stream, 0, 1, "high_precision_offsets_enabled_flag");
|
|
|
|
WRITE_U(stream, 0, 1, "persistent_rice_adaptation_enabled_flag");
|
|
|
|
WRITE_U(stream, 0, 1, "cabac_bypass_alignment_enabled_flag");
|
2018-07-25 07:05:11 +00:00
|
|
|
|
2018-07-25 09:24:17 +00:00
|
|
|
// Next extension
|
|
|
|
WRITE_U(stream, 1, 1, "qtbt_flag");
|
|
|
|
WRITE_U(stream, 0, 1, "large_ctu_flag");
|
|
|
|
WRITE_U(stream, 0, 1, "disable_motion_compression_flag");
|
|
|
|
WRITE_U(stream, 0, 5, "reserved_flag_5bits");
|
|
|
|
|
|
|
|
WRITE_U(stream, 0, 1, "mtt_enabled_flag");
|
|
|
|
WRITE_U(stream, 0, 1, "next_dqp_enabled_flag");
|
|
|
|
|
|
|
|
// QTBT
|
2018-07-26 13:12:11 +00:00
|
|
|
WRITE_U(stream, 0, 1, "qtbt_dual_intra_tree");
|
2018-07-25 09:24:17 +00:00
|
|
|
WRITE_UE(stream, 5, "log2_CTU_size_minus2");
|
|
|
|
WRITE_UE(stream, 0, "log2_minQT_ISlice_minus2");
|
|
|
|
WRITE_UE(stream, 0, "log2_minQT_PBSlice_minus2");
|
2018-07-26 13:12:11 +00:00
|
|
|
WRITE_UE(stream, 0, "max_bt_depth");
|
|
|
|
WRITE_UE(stream, 0, "max_bt_depth_i_slice");
|
2018-07-25 09:24:17 +00:00
|
|
|
|
|
|
|
//} else {
|
|
|
|
// WRITE_U(stream, 0, 1, "sps_extension_present_flag");
|
|
|
|
// }
|
2016-08-03 05:18:56 +00:00
|
|
|
}
|
|
|
|
|
2015-10-14 09:33:07 +00:00
|
|
|
static void encoder_state_write_bitstream_seq_parameter_set(bitstream_t* stream,
|
|
|
|
encoder_state_t * const state)
|
2014-06-03 12:47:49 +00:00
|
|
|
{
|
2015-03-04 15:00:23 +00:00
|
|
|
const encoder_control_t * encoder = state->encoder_control;
|
2014-06-03 12:47:49 +00:00
|
|
|
|
2015-09-14 09:43:28 +00:00
|
|
|
#ifdef KVZ_DEBUG
|
2014-06-03 12:47:49 +00:00
|
|
|
printf("=========== Sequence Parameter Set ID: 0 ===========\n");
|
|
|
|
#endif
|
|
|
|
|
|
|
|
// TODO: profile IDC and level IDC should be defined later on
|
2018-07-25 07:05:11 +00:00
|
|
|
//WRITE_U(stream, 0, 4, "sps_video_parameter_set_id");
|
2014-06-03 12:47:49 +00:00
|
|
|
WRITE_U(stream, 1, 3, "sps_max_sub_layers_minus1");
|
|
|
|
WRITE_U(stream, 0, 1, "sps_temporal_id_nesting_flag");
|
|
|
|
|
2015-10-14 09:33:07 +00:00
|
|
|
encoder_state_write_bitstream_PTL(stream, state);
|
2014-06-03 12:47:49 +00:00
|
|
|
|
|
|
|
WRITE_UE(stream, 0, "sps_seq_parameter_set_id");
|
2016-08-25 13:05:46 +00:00
|
|
|
WRITE_UE(stream, encoder->chroma_format, "chroma_format_idc");
|
2014-06-03 12:47:49 +00:00
|
|
|
|
2016-08-25 13:05:46 +00:00
|
|
|
if (encoder->chroma_format == KVZ_CSP_444) {
|
2014-06-03 12:47:49 +00:00
|
|
|
WRITE_U(stream, 0, 1, "separate_colour_plane_flag");
|
|
|
|
}
|
|
|
|
|
2014-06-05 12:54:58 +00:00
|
|
|
WRITE_UE(stream, encoder->in.width, "pic_width_in_luma_samples");
|
|
|
|
WRITE_UE(stream, encoder->in.height, "pic_height_in_luma_samples");
|
2014-06-03 12:47:49 +00:00
|
|
|
|
2014-06-05 12:54:58 +00:00
|
|
|
if (encoder->in.width != encoder->in.real_width || encoder->in.height != encoder->in.real_height) {
|
2014-06-03 12:47:49 +00:00
|
|
|
// The standard does not seem to allow setting conf_win values such that
|
|
|
|
// the number of luma samples is not a multiple of 2. Options are to either
|
|
|
|
// hide one line or show an extra line of non-video. Neither seems like a
|
|
|
|
// very good option, so let's not even try.
|
2014-06-05 12:54:58 +00:00
|
|
|
assert(!(encoder->in.width % 2));
|
2014-06-03 12:47:49 +00:00
|
|
|
WRITE_U(stream, 1, 1, "conformance_window_flag");
|
|
|
|
WRITE_UE(stream, 0, "conf_win_left_offset");
|
2014-06-05 12:54:58 +00:00
|
|
|
WRITE_UE(stream, (encoder->in.width - encoder->in.real_width) >> 1,
|
2014-06-03 12:47:49 +00:00
|
|
|
"conf_win_right_offset");
|
|
|
|
WRITE_UE(stream, 0, "conf_win_top_offset");
|
2014-06-05 12:54:58 +00:00
|
|
|
WRITE_UE(stream, (encoder->in.height - encoder->in.real_height) >> 1,
|
2014-06-03 12:47:49 +00:00
|
|
|
"conf_win_bottom_offset");
|
|
|
|
} else {
|
|
|
|
WRITE_U(stream, 0, 1, "conformance_window_flag");
|
|
|
|
}
|
|
|
|
|
|
|
|
//IF window flag
|
|
|
|
//END IF
|
|
|
|
|
2015-04-29 12:10:37 +00:00
|
|
|
WRITE_UE(stream, encoder->bitdepth-8, "bit_depth_luma_minus8");
|
|
|
|
WRITE_UE(stream, encoder->bitdepth-8, "bit_depth_chroma_minus8");
|
2015-03-10 07:06:32 +00:00
|
|
|
WRITE_UE(stream, 1, "log2_max_pic_order_cnt_lsb_minus4");
|
2014-06-03 12:47:49 +00:00
|
|
|
WRITE_U(stream, 0, 1, "sps_sub_layer_ordering_info_present_flag");
|
|
|
|
|
|
|
|
//for each layer
|
2017-02-05 09:59:21 +00:00
|
|
|
if (encoder->cfg.gop_lowdelay) {
|
2018-07-25 07:05:11 +00:00
|
|
|
WRITE_UE(stream, encoder->cfg.ref_frames, "sps_max_dec_pic_buffering_minus1");
|
|
|
|
WRITE_UE(stream, 0, "sps_max_num_reorder_pics");
|
2015-11-12 17:05:06 +00:00
|
|
|
} else {
|
2018-07-25 07:05:11 +00:00
|
|
|
WRITE_UE(stream, encoder->cfg.ref_frames + encoder->cfg.gop_len, "sps_max_dec_pic_buffering_minus1");
|
|
|
|
WRITE_UE(stream, encoder->cfg.gop_len, "sps_max_num_reorder_pics");
|
2015-11-12 17:05:06 +00:00
|
|
|
}
|
2018-07-25 07:05:11 +00:00
|
|
|
WRITE_UE(stream, 0, "sps_max_latency_increase_plus1");
|
2014-06-03 12:47:49 +00:00
|
|
|
//end for
|
|
|
|
|
2018-07-25 07:05:11 +00:00
|
|
|
WRITE_UE(stream, MIN_SIZE-3, "log2_min_luma_coding_block_size_minus3");
|
|
|
|
WRITE_UE(stream, MAX_DEPTH, "log2_diff_max_min_luma_coding_block_size");
|
|
|
|
|
|
|
|
// ToDo: redefine for VVC
|
|
|
|
WRITE_UE(stream, 0, "log2_min_luma_transform_block_size_minus2"); // 4x4
|
|
|
|
WRITE_UE(stream, 3, "log2_diff_max_min_luma_transform_block_size"); // 4x4...32x32
|
2018-07-26 13:12:11 +00:00
|
|
|
WRITE_UE(stream, 0/*encoder->tr_depth_inter*/, "max_transform_hierarchy_depth_inter");
|
|
|
|
WRITE_UE(stream, 0/*encoder->cfg.tr_depth_intra*/, "max_transform_hierarchy_depth_intra");
|
2018-07-25 07:05:11 +00:00
|
|
|
/*
|
2014-06-03 12:47:49 +00:00
|
|
|
// scaling list
|
2015-10-14 09:32:38 +00:00
|
|
|
WRITE_U(stream, encoder->scaling_list.enable, 1, "scaling_list_enable_flag");
|
|
|
|
if (encoder->scaling_list.enable) {
|
2014-06-03 12:47:49 +00:00
|
|
|
WRITE_U(stream, 1, 1, "sps_scaling_list_data_present_flag");
|
2015-10-14 09:33:07 +00:00
|
|
|
encoder_state_write_bitstream_scaling_list(stream, state);
|
2014-06-03 12:47:49 +00:00
|
|
|
}
|
2018-07-25 07:05:11 +00:00
|
|
|
*/
|
2017-02-05 09:59:21 +00:00
|
|
|
WRITE_U(stream, (encoder->cfg.amp_enable ? 1 : 0), 1, "amp_enabled_flag");
|
2015-12-01 12:37:58 +00:00
|
|
|
|
2017-08-11 08:57:09 +00:00
|
|
|
WRITE_U(stream, encoder->cfg.sao_type ? 1 : 0, 1,
|
2014-06-03 12:47:49 +00:00
|
|
|
"sample_adaptive_offset_enabled_flag");
|
|
|
|
WRITE_U(stream, ENABLE_PCM, 1, "pcm_enabled_flag");
|
|
|
|
#if ENABLE_PCM == 1
|
|
|
|
WRITE_U(stream, 7, 4, "pcm_sample_bit_depth_luma_minus1");
|
|
|
|
WRITE_U(stream, 7, 4, "pcm_sample_bit_depth_chroma_minus1");
|
|
|
|
WRITE_UE(stream, 0, "log2_min_pcm_coding_block_size_minus3");
|
|
|
|
WRITE_UE(stream, 2, "log2_diff_max_min_pcm_coding_block_size");
|
|
|
|
WRITE_U(stream, 1, 1, "pcm_loop_filter_disable_flag");
|
|
|
|
#endif
|
|
|
|
|
|
|
|
WRITE_UE(stream, 0, "num_short_term_ref_pic_sets");
|
|
|
|
|
|
|
|
//IF num short term ref pic sets
|
|
|
|
//ENDIF
|
|
|
|
|
|
|
|
WRITE_U(stream, 0, 1, "long_term_ref_pics_present_flag");
|
|
|
|
|
|
|
|
//IF long_term_ref_pics_present
|
|
|
|
//ENDIF
|
|
|
|
|
2017-02-05 09:59:21 +00:00
|
|
|
WRITE_U(stream, state->encoder_control->cfg.tmvp_enable, 1,
|
2014-06-03 12:47:49 +00:00
|
|
|
"sps_temporal_mvp_enable_flag");
|
2018-07-25 07:05:11 +00:00
|
|
|
//WRITE_U(stream, 0, 1, "sps_strong_intra_smoothing_enable_flag");
|
2014-06-03 12:47:49 +00:00
|
|
|
WRITE_U(stream, 1, 1, "vui_parameters_present_flag");
|
|
|
|
|
2015-10-14 09:33:07 +00:00
|
|
|
encoder_state_write_bitstream_VUI(stream, state);
|
2014-06-03 12:47:49 +00:00
|
|
|
|
2016-08-03 05:18:56 +00:00
|
|
|
encoder_state_write_bitstream_SPS_extension(stream, state);
|
2015-08-27 12:05:44 +00:00
|
|
|
|
|
|
|
kvz_bitstream_add_rbsp_trailing_bits(stream);
|
2014-06-03 12:47:49 +00:00
|
|
|
}
|
|
|
|
|
2015-10-14 09:33:07 +00:00
|
|
|
static void encoder_state_write_bitstream_pic_parameter_set(bitstream_t* stream,
|
|
|
|
encoder_state_t * const state)
|
2014-06-03 12:47:49 +00:00
|
|
|
{
|
2015-03-04 15:00:23 +00:00
|
|
|
const encoder_control_t * const encoder = state->encoder_control;
|
2015-09-14 09:43:28 +00:00
|
|
|
#ifdef KVZ_DEBUG
|
2014-06-03 12:47:49 +00:00
|
|
|
printf("=========== Picture Parameter Set ID: 0 ===========\n");
|
|
|
|
#endif
|
|
|
|
WRITE_UE(stream, 0, "pic_parameter_set_id");
|
|
|
|
WRITE_UE(stream, 0, "seq_parameter_set_id");
|
2018-07-26 07:43:21 +00:00
|
|
|
//WRITE_U(stream, encoder->pps.dependent_slice_segments_enabled_flag, 1, "dependent_slice_segments_enabled_flag");
|
2014-06-03 12:47:49 +00:00
|
|
|
WRITE_U(stream, 0, 1, "output_flag_present_flag");
|
|
|
|
WRITE_U(stream, 0, 3, "num_extra_slice_header_bits");
|
2018-07-26 07:41:35 +00:00
|
|
|
//WRITE_U(stream, encoder->cfg.signhide_enable, 1, "sign_data_hiding_flag");
|
2014-06-03 12:47:49 +00:00
|
|
|
WRITE_U(stream, 0, 1, "cabac_init_present_flag");
|
|
|
|
|
|
|
|
WRITE_UE(stream, 0, "num_ref_idx_l0_default_active_minus1");
|
|
|
|
WRITE_UE(stream, 0, "num_ref_idx_l1_default_active_minus1");
|
2017-02-05 09:59:21 +00:00
|
|
|
WRITE_SE(stream, ((int8_t)encoder->cfg.qp) - 26, "pic_init_qp_minus26");
|
2014-06-03 12:47:49 +00:00
|
|
|
WRITE_U(stream, 0, 1, "constrained_intra_pred_flag");
|
2017-02-06 11:00:25 +00:00
|
|
|
WRITE_U(stream, encoder->cfg.trskip_enable, 1, "transform_skip_enabled_flag");
|
2016-08-21 04:36:13 +00:00
|
|
|
|
2017-05-08 07:54:06 +00:00
|
|
|
if (encoder->max_qp_delta_depth >= 0) {
|
2016-08-21 04:36:13 +00:00
|
|
|
// Use separate QP for each LCU when rate control is enabled.
|
|
|
|
WRITE_U(stream, 1, 1, "cu_qp_delta_enabled_flag");
|
2017-05-08 07:54:06 +00:00
|
|
|
WRITE_UE(stream, encoder->max_qp_delta_depth, "diff_cu_qp_delta_depth");
|
2016-08-21 04:36:13 +00:00
|
|
|
} else {
|
2017-05-08 07:54:06 +00:00
|
|
|
WRITE_U(stream, 0, 1, "cu_qp_delta_enabled_flag");
|
2016-08-21 04:36:13 +00:00
|
|
|
}
|
2014-06-03 12:47:49 +00:00
|
|
|
|
|
|
|
//TODO: add QP offsets
|
|
|
|
WRITE_SE(stream, 0, "pps_cb_qp_offset");
|
|
|
|
WRITE_SE(stream, 0, "pps_cr_qp_offset");
|
|
|
|
WRITE_U(stream, 0, 1, "pps_slice_chroma_qp_offsets_present_flag");
|
|
|
|
WRITE_U(stream, 0, 1, "weighted_pred_flag");
|
|
|
|
WRITE_U(stream, 0, 1, "weighted_bipred_idc");
|
|
|
|
|
|
|
|
//WRITE_U(stream, 0, 1, "dependent_slices_enabled_flag");
|
2017-02-05 09:59:21 +00:00
|
|
|
WRITE_U(stream, encoder->cfg.lossless, 1, "transquant_bypass_enable_flag");
|
2018-07-26 07:43:21 +00:00
|
|
|
|
|
|
|
/*
|
2014-06-03 12:47:49 +00:00
|
|
|
WRITE_U(stream, encoder->tiles_enable, 1, "tiles_enabled_flag");
|
|
|
|
//wavefronts
|
2017-02-06 11:00:25 +00:00
|
|
|
WRITE_U(stream, encoder->cfg.wpp, 1, "entropy_coding_sync_enabled_flag");
|
2014-06-03 12:47:49 +00:00
|
|
|
|
|
|
|
if (encoder->tiles_enable) {
|
2017-02-06 11:00:25 +00:00
|
|
|
WRITE_UE(stream, encoder->cfg.tiles_width_count - 1, "num_tile_columns_minus1");
|
|
|
|
WRITE_UE(stream, encoder->cfg.tiles_height_count - 1, "num_tile_rows_minus1");
|
2014-06-03 12:47:49 +00:00
|
|
|
|
|
|
|
WRITE_U(stream, encoder->tiles_uniform_spacing_flag, 1, "uniform_spacing_flag");
|
|
|
|
|
|
|
|
if (!encoder->tiles_uniform_spacing_flag) {
|
|
|
|
int i;
|
2017-02-06 11:00:25 +00:00
|
|
|
for (i = 0; i < encoder->cfg.tiles_width_count - 1; ++i) {
|
2014-06-03 12:47:49 +00:00
|
|
|
WRITE_UE(stream, encoder->tiles_col_width[i] - 1, "column_width_minus1[...]");
|
|
|
|
}
|
2017-02-06 11:00:25 +00:00
|
|
|
for (i = 0; i < encoder->cfg.tiles_height_count - 1; ++i) {
|
2014-06-03 12:47:49 +00:00
|
|
|
WRITE_UE(stream, encoder->tiles_row_height[i] - 1, "row_height_minus1[...]");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
WRITE_U(stream, 0, 1, "loop_filter_across_tiles_enabled_flag");
|
|
|
|
|
|
|
|
}
|
2018-07-26 07:43:21 +00:00
|
|
|
*/
|
2014-06-03 12:47:49 +00:00
|
|
|
WRITE_U(stream, 0, 1, "loop_filter_across_slice_flag");
|
|
|
|
WRITE_U(stream, 1, 1, "deblocking_filter_control_present_flag");
|
|
|
|
|
|
|
|
//IF deblocking_filter
|
|
|
|
WRITE_U(stream, 0, 1, "deblocking_filter_override_enabled_flag");
|
2017-02-06 11:00:25 +00:00
|
|
|
WRITE_U(stream, encoder->cfg.deblock_enable ? 0 : 1, 1,
|
2014-06-03 12:47:49 +00:00
|
|
|
"pps_disable_deblocking_filter_flag");
|
|
|
|
|
|
|
|
//IF !disabled
|
2017-02-06 11:00:25 +00:00
|
|
|
if (encoder->cfg.deblock_enable) {
|
|
|
|
WRITE_SE(stream, encoder->cfg.deblock_beta, "beta_offset_div2");
|
|
|
|
WRITE_SE(stream, encoder->cfg.deblock_tc, "tc_offset_div2");
|
2014-06-03 12:47:49 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
//ENDIF
|
|
|
|
//ENDIF
|
2018-07-26 07:43:21 +00:00
|
|
|
//WRITE_U(stream, 0, 1, "pps_scaling_list_data_present_flag");
|
2014-06-03 12:47:49 +00:00
|
|
|
//IF scaling_list
|
|
|
|
//ENDIF
|
|
|
|
WRITE_U(stream, 0, 1, "lists_modification_present_flag");
|
|
|
|
WRITE_UE(stream, 0, "log2_parallel_merge_level_minus2");
|
|
|
|
WRITE_U(stream, 0, 1, "slice_segment_header_extension_present_flag");
|
|
|
|
WRITE_U(stream, 0, 1, "pps_extension_flag");
|
2015-08-27 12:05:44 +00:00
|
|
|
|
|
|
|
kvz_bitstream_add_rbsp_trailing_bits(stream);
|
2014-06-03 12:47:49 +00:00
|
|
|
}
|
|
|
|
|
2015-03-04 15:00:23 +00:00
|
|
|
static void encoder_state_write_bitstream_prefix_sei_version(encoder_state_t * const state)
|
2014-06-03 12:47:49 +00:00
|
|
|
{
|
|
|
|
#define STR_BUF_LEN 1000
|
2015-03-04 15:00:23 +00:00
|
|
|
bitstream_t * const stream = &state->stream;
|
2014-06-03 12:47:49 +00:00
|
|
|
int i, length;
|
|
|
|
char buf[STR_BUF_LEN] = { 0 };
|
|
|
|
char *s = buf + 16;
|
2017-02-05 09:59:21 +00:00
|
|
|
const kvz_config * const cfg = &state->encoder_control->cfg;
|
2014-06-03 12:47:49 +00:00
|
|
|
|
|
|
|
// random uuid_iso_iec_11578 generated with www.famkruithof.net/uuid/uuidgen
|
|
|
|
static const uint8_t uuid[16] = {
|
|
|
|
0x32, 0xfe, 0x46, 0x6c, 0x98, 0x41, 0x42, 0x69,
|
|
|
|
0xae, 0x35, 0x6a, 0x91, 0x54, 0x9e, 0xf3, 0xf1
|
|
|
|
};
|
|
|
|
memcpy(buf, uuid, 16);
|
|
|
|
|
|
|
|
// user_data_payload_byte
|
2018-07-26 05:17:55 +00:00
|
|
|
s += sprintf(s, "Kvazaar VVC Encoder v. " VERSION_STRING " - "
|
|
|
|
"Copyleft 2018- - http://ultravideo.cs.tut.fi/ - options:");
|
2014-06-03 12:47:49 +00:00
|
|
|
s += sprintf(s, " %dx%d", cfg->width, cfg->height);
|
|
|
|
s += sprintf(s, " deblock=%d:%d:%d", cfg->deblock_enable,
|
|
|
|
cfg->deblock_beta, cfg->deblock_tc);
|
2017-08-11 08:57:09 +00:00
|
|
|
s += sprintf(s, " sao=%d", cfg->sao_type);
|
2014-06-03 12:47:49 +00:00
|
|
|
s += sprintf(s, " intra_period=%d", cfg->intra_period);
|
|
|
|
s += sprintf(s, " qp=%d", cfg->qp);
|
|
|
|
s += sprintf(s, " ref=%d", cfg->ref_frames);
|
|
|
|
|
|
|
|
length = (int)(s - buf + 1); // length, +1 for \0
|
|
|
|
|
|
|
|
// Assert this so that in the future if the message gets longer, we remember
|
|
|
|
// to increase the buf len. Divide by 2 for margin.
|
|
|
|
assert(length < STR_BUF_LEN / 2);
|
|
|
|
|
|
|
|
// payloadType = 5 -> user_data_unregistered
|
|
|
|
WRITE_U(stream, 5, 8, "last_payload_type_byte");
|
|
|
|
|
|
|
|
// payloadSize
|
|
|
|
for (i = 0; i <= length - 255; i += 255)
|
|
|
|
WRITE_U(stream, 255, 8, "ff_byte");
|
|
|
|
WRITE_U(stream, length - i, 8, "last_payload_size_byte");
|
|
|
|
|
|
|
|
for (i = 0; i < length; i++)
|
|
|
|
WRITE_U(stream, ((uint8_t *)buf)[i], 8, "sei_payload");
|
|
|
|
|
2015-08-27 12:05:44 +00:00
|
|
|
// The bitstream is already aligned, but align it anyway.
|
|
|
|
kvz_bitstream_align(stream);
|
|
|
|
|
2014-06-03 12:47:49 +00:00
|
|
|
#undef STR_BUF_LEN
|
|
|
|
}
|
|
|
|
|
2015-04-08 14:17:45 +00:00
|
|
|
/*
|
|
|
|
static void encoder_state_write_active_parameter_sets_sei_message(encoder_state_t * const state) {
|
|
|
|
|
|
|
|
const encoder_control_t * const encoder = state->encoder_control;
|
|
|
|
bitstream_t * const stream = &state->stream;
|
|
|
|
|
|
|
|
int i = 0;
|
|
|
|
|
|
|
|
int active_vps_id = 0;
|
|
|
|
int self_contained_cvs_flag = 0;
|
|
|
|
int no_parameter_set_update_flag = 0;
|
|
|
|
int num_sps_ids_minus1 = 0;
|
|
|
|
int layer_sps_idx = 0;
|
|
|
|
int active_seq_parameter_set_id = 0;
|
|
|
|
int vps_base_layer_internal_flag = 0;
|
|
|
|
|
|
|
|
int max_layers_minus1 = 0;
|
|
|
|
|
|
|
|
WRITE_U(stream, 129, 8, "last_payload_type_byte"); //active_parameter_sets
|
|
|
|
WRITE_U(stream, 2, 8, "last_payload_size_byte");
|
|
|
|
WRITE_U(stream, active_vps_id, 4, "active_video_parameter_set_id");
|
|
|
|
WRITE_U(stream, self_contained_cvs_flag, 1, "self_contained_cvs_flag");
|
|
|
|
WRITE_U(stream, no_parameter_set_update_flag, 1, "no_parameter_set_update_flag");
|
|
|
|
WRITE_UE(stream, num_sps_ids_minus1, "num_sps_ids_minus1");
|
|
|
|
//for (i = 0; i <= num_sps_ids_minus1; ++i) {
|
|
|
|
WRITE_UE(stream, active_seq_parameter_set_id, "active_seq_parameter_set_id");
|
|
|
|
//}
|
|
|
|
// for (i = vps_base_layer_internal_flag; i <= max_layers_minus1; ++i){
|
|
|
|
WRITE_UE(stream, layer_sps_idx, "layer_sps_idx");
|
|
|
|
//}
|
|
|
|
|
2015-08-27 11:33:30 +00:00
|
|
|
kvz_bitstream_rbsp_trailing_bits(stream); //rbsp_trailing_bits
|
2015-04-08 14:17:45 +00:00
|
|
|
}
|
|
|
|
*/
|
|
|
|
|
|
|
|
static void encoder_state_write_picture_timing_sei_message(encoder_state_t * const state) {
|
|
|
|
|
|
|
|
bitstream_t * const stream = &state->stream;
|
|
|
|
|
|
|
|
if (state->encoder_control->vui.frame_field_info_present_flag){
|
|
|
|
|
2016-08-10 00:46:23 +00:00
|
|
|
int8_t odd_picture = state->frame->num % 2;
|
2015-04-08 14:17:45 +00:00
|
|
|
int8_t pic_struct = 0; //0: progressive picture, 1: top field, 2: bottom field, 3...
|
|
|
|
int8_t source_scan_type = 1; //0: interlaced, 1: progressive
|
|
|
|
|
2016-01-25 17:05:10 +00:00
|
|
|
switch (state->tile->frame->source->interlacing){
|
2015-04-08 14:17:45 +00:00
|
|
|
case 0: //Progressive frame
|
|
|
|
pic_struct = 0;
|
|
|
|
source_scan_type = 1;
|
|
|
|
break;
|
|
|
|
case 1: //Top field first
|
|
|
|
pic_struct = odd_picture ? 2 : 1;
|
|
|
|
source_scan_type = 0;
|
|
|
|
break;
|
|
|
|
case 2: //Bottom field first
|
|
|
|
pic_struct = odd_picture ? 1 : 2;
|
|
|
|
source_scan_type = 0;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
assert(0); //Should never execute
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
WRITE_U(stream, 1, 8, "last_payload_type_byte"); //pic_timing
|
|
|
|
WRITE_U(stream, 1, 8, "last_payload_size_byte");
|
|
|
|
WRITE_U(stream, pic_struct, 4, "pic_struct");
|
|
|
|
WRITE_U(stream, source_scan_type, 2, "source_scan_type");
|
|
|
|
WRITE_U(stream, 0, 1, "duplicate_flag");
|
|
|
|
|
2015-08-27 11:56:05 +00:00
|
|
|
kvz_bitstream_align(stream);
|
2015-04-08 14:17:45 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2015-03-04 15:00:23 +00:00
|
|
|
static void encoder_state_entry_points_explore(const encoder_state_t * const state, int * const r_count, int * const r_max_length) {
|
2014-06-03 12:47:49 +00:00
|
|
|
int i;
|
2015-03-04 15:00:23 +00:00
|
|
|
for (i = 0; state->children[i].encoder_control; ++i) {
|
|
|
|
if (state->children[i].is_leaf) {
|
2015-08-26 08:50:27 +00:00
|
|
|
const int my_length = kvz_bitstream_tell(&state->children[i].stream)/8;
|
2014-06-03 12:47:49 +00:00
|
|
|
++(*r_count);
|
|
|
|
if (my_length > *r_max_length) {
|
|
|
|
*r_max_length = my_length;
|
|
|
|
}
|
|
|
|
} else {
|
2015-03-04 15:00:23 +00:00
|
|
|
encoder_state_entry_points_explore(&state->children[i], r_count, r_max_length);
|
2014-06-03 12:47:49 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-03-04 15:00:23 +00:00
|
|
|
static void encoder_state_write_bitstream_entry_points_write(bitstream_t * const stream, const encoder_state_t * const state, const int num_entry_points, const int write_length, int * const r_count) {
|
2014-06-03 12:47:49 +00:00
|
|
|
int i;
|
2015-03-04 15:00:23 +00:00
|
|
|
for (i = 0; state->children[i].encoder_control; ++i) {
|
|
|
|
if (state->children[i].is_leaf) {
|
2015-08-26 08:50:27 +00:00
|
|
|
const int my_length = kvz_bitstream_tell(&state->children[i].stream)/8;
|
2014-06-03 12:47:49 +00:00
|
|
|
++(*r_count);
|
|
|
|
//Don't write the last one
|
|
|
|
if (*r_count < num_entry_points) {
|
|
|
|
WRITE_U(stream, my_length - 1, write_length, "entry_point_offset-minus1")
|
|
|
|
}
|
|
|
|
} else {
|
2015-03-04 15:00:23 +00:00
|
|
|
encoder_state_write_bitstream_entry_points_write(stream, &state->children[i], num_entry_points, write_length, r_count);
|
2014-06-03 12:47:49 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-01-31 13:11:50 +00:00
|
|
|
static void kvz_encoder_state_write_bitstream_slice_header_independent(
|
2017-01-31 11:26:56 +00:00
|
|
|
struct bitstream_t * const stream,
|
|
|
|
struct encoder_state_t * const state)
|
2014-06-03 12:47:49 +00:00
|
|
|
{
|
2015-03-04 15:00:23 +00:00
|
|
|
const encoder_control_t * const encoder = state->encoder_control;
|
2017-01-31 13:11:50 +00:00
|
|
|
|
2015-03-11 13:19:32 +00:00
|
|
|
int j;
|
|
|
|
int ref_negative = 0;
|
|
|
|
int ref_positive = 0;
|
2017-02-05 09:59:21 +00:00
|
|
|
if (encoder->cfg.gop_len) {
|
2016-08-10 00:46:23 +00:00
|
|
|
for (j = 0; j < state->frame->ref->used_size; j++) {
|
|
|
|
if (state->frame->ref->pocs[j] < state->frame->poc) {
|
2015-03-11 13:19:32 +00:00
|
|
|
ref_negative++;
|
|
|
|
} else {
|
|
|
|
ref_positive++;
|
|
|
|
}
|
|
|
|
}
|
2016-08-10 00:46:23 +00:00
|
|
|
} else ref_negative = state->frame->ref->used_size;
|
2014-06-03 12:47:49 +00:00
|
|
|
|
2016-08-10 00:46:23 +00:00
|
|
|
WRITE_UE(stream, state->frame->slicetype, "slice_type");
|
2014-06-03 12:47:49 +00:00
|
|
|
|
2016-08-10 00:46:23 +00:00
|
|
|
if (state->frame->pictype != KVZ_NAL_IDR_W_RADL
|
2017-01-31 13:11:50 +00:00
|
|
|
&& state->frame->pictype != KVZ_NAL_IDR_N_LP)
|
|
|
|
{
|
2015-03-11 13:19:32 +00:00
|
|
|
int last_poc = 0;
|
2015-03-26 08:38:21 +00:00
|
|
|
int poc_shift = 0;
|
2015-03-06 14:28:23 +00:00
|
|
|
|
2016-09-30 11:59:47 +00:00
|
|
|
WRITE_U(stream, state->frame->poc&0x1f, 5, "pic_order_cnt_lsb");
|
|
|
|
WRITE_U(stream, 0, 1, "short_term_ref_pic_set_sps_flag");
|
|
|
|
WRITE_UE(stream, ref_negative, "num_negative_pics");
|
|
|
|
WRITE_UE(stream, ref_positive, "num_positive_pics");
|
2015-03-26 08:38:21 +00:00
|
|
|
for (j = 0; j < ref_negative; j++) {
|
|
|
|
int8_t delta_poc = 0;
|
|
|
|
|
2017-02-05 09:59:21 +00:00
|
|
|
if (encoder->cfg.gop_len) {
|
2015-03-26 08:38:21 +00:00
|
|
|
int8_t found = 0;
|
|
|
|
do {
|
2017-02-05 09:59:21 +00:00
|
|
|
delta_poc = encoder->cfg.gop[state->frame->gop_offset].ref_neg[j + poc_shift];
|
2016-08-10 00:46:23 +00:00
|
|
|
for (int i = 0; i < state->frame->ref->used_size; i++) {
|
|
|
|
if (state->frame->ref->pocs[i] == state->frame->poc - delta_poc) {
|
2015-03-26 08:38:21 +00:00
|
|
|
found = 1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2015-03-26 08:40:21 +00:00
|
|
|
if (!found) poc_shift++;
|
|
|
|
if (j + poc_shift == ref_negative) {
|
|
|
|
fprintf(stderr, "Failure, reference not found!");
|
|
|
|
exit(EXIT_FAILURE);
|
|
|
|
}
|
2015-03-26 08:38:21 +00:00
|
|
|
} while (!found);
|
|
|
|
}
|
2014-06-03 12:47:49 +00:00
|
|
|
|
2017-02-05 09:59:21 +00:00
|
|
|
WRITE_UE(stream, encoder->cfg.gop_len?delta_poc - last_poc - 1:0, "delta_poc_s0_minus1");
|
2015-03-20 08:25:40 +00:00
|
|
|
last_poc = delta_poc;
|
2017-10-19 10:25:57 +00:00
|
|
|
WRITE_U(stream, !state->frame->is_irap, 1, "used_by_curr_pic_s0_flag");
|
2014-06-03 12:47:49 +00:00
|
|
|
}
|
2015-03-11 13:19:32 +00:00
|
|
|
last_poc = 0;
|
2015-03-26 08:38:21 +00:00
|
|
|
poc_shift = 0;
|
|
|
|
for (j = 0; j < ref_positive; j++) {
|
|
|
|
int8_t delta_poc = 0;
|
|
|
|
|
2017-02-05 09:59:21 +00:00
|
|
|
if (encoder->cfg.gop_len) {
|
2015-03-26 08:38:21 +00:00
|
|
|
int8_t found = 0;
|
|
|
|
do {
|
2017-02-05 09:59:21 +00:00
|
|
|
delta_poc = encoder->cfg.gop[state->frame->gop_offset].ref_pos[j + poc_shift];
|
2016-08-10 00:46:23 +00:00
|
|
|
for (int i = 0; i < state->frame->ref->used_size; i++) {
|
|
|
|
if (state->frame->ref->pocs[i] == state->frame->poc + delta_poc) {
|
2015-03-26 08:38:21 +00:00
|
|
|
found = 1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2015-03-26 08:40:21 +00:00
|
|
|
if (!found) poc_shift++;
|
|
|
|
if (j + poc_shift == ref_positive) {
|
|
|
|
fprintf(stderr, "Failure, reference not found!");
|
|
|
|
exit(EXIT_FAILURE);
|
|
|
|
}
|
2015-03-26 08:38:21 +00:00
|
|
|
} while (!found);
|
|
|
|
}
|
2015-03-20 08:25:40 +00:00
|
|
|
|
2017-02-05 09:59:21 +00:00
|
|
|
WRITE_UE(stream, encoder->cfg.gop_len ? delta_poc - last_poc - 1 : 0, "delta_poc_s1_minus1");
|
2015-03-20 08:25:40 +00:00
|
|
|
last_poc = delta_poc;
|
2017-10-19 10:25:57 +00:00
|
|
|
WRITE_U(stream, !state->frame->is_irap, 1, "used_by_curr_pic_s1_flag");
|
2015-03-06 14:28:23 +00:00
|
|
|
}
|
2014-06-03 12:47:49 +00:00
|
|
|
//WRITE_UE(stream, 0, "short_term_ref_pic_set_idx");
|
2016-08-10 11:51:41 +00:00
|
|
|
|
2017-02-05 09:59:21 +00:00
|
|
|
if (state->encoder_control->cfg.tmvp_enable) {
|
2017-10-19 10:25:57 +00:00
|
|
|
WRITE_U(stream, ref_negative ? 1 : 0, 1, "slice_temporal_mvp_enabled_flag");
|
2016-08-10 11:51:41 +00:00
|
|
|
}
|
2014-06-03 12:47:49 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
//end if
|
|
|
|
//end if
|
2016-06-14 05:34:17 +00:00
|
|
|
|
|
|
|
|
2017-08-11 08:57:09 +00:00
|
|
|
if (encoder->cfg.sao_type) {
|
2014-06-03 12:47:49 +00:00
|
|
|
WRITE_U(stream, 1, 1, "slice_sao_luma_flag");
|
2016-08-25 13:05:46 +00:00
|
|
|
if (encoder->chroma_format != KVZ_CSP_400) {
|
|
|
|
WRITE_U(stream, 1, 1, "slice_sao_chroma_flag");
|
|
|
|
}
|
2014-06-03 12:47:49 +00:00
|
|
|
}
|
2018-01-31 11:50:57 +00:00
|
|
|
|
2016-08-10 00:46:23 +00:00
|
|
|
if (state->frame->slicetype != KVZ_SLICE_I) {
|
2014-06-03 12:47:49 +00:00
|
|
|
WRITE_U(stream, 1, 1, "num_ref_idx_active_override_flag");
|
2018-01-31 11:50:57 +00:00
|
|
|
WRITE_UE(stream, MAX(0, ((int)state->frame->ref_LX_size[0]) - 1), "num_ref_idx_l0_active_minus1");
|
2016-09-30 11:59:47 +00:00
|
|
|
if (state->frame->slicetype == KVZ_SLICE_B) {
|
2018-01-31 11:50:57 +00:00
|
|
|
WRITE_UE(stream, MAX(0, ((int)state->frame->ref_LX_size[1]) - 1), "num_ref_idx_l1_active_minus1");
|
2016-09-30 11:59:47 +00:00
|
|
|
WRITE_U(stream, 0, 1, "mvd_l1_zero_flag");
|
|
|
|
}
|
|
|
|
|
|
|
|
// Temporal Motion Vector Prediction flags
|
2017-01-05 12:03:55 +00:00
|
|
|
if (state->encoder_control->cfg.tmvp_enable && ref_negative > 0) {
|
2016-08-10 00:46:23 +00:00
|
|
|
if (state->frame->slicetype == KVZ_SLICE_B) {
|
2016-09-30 11:59:47 +00:00
|
|
|
// Always use L0 for prediction
|
|
|
|
WRITE_U(stream, 1, 1, "collocated_from_l0_flag");
|
2015-03-06 14:27:42 +00:00
|
|
|
}
|
2016-08-10 08:28:09 +00:00
|
|
|
|
2016-09-30 11:59:47 +00:00
|
|
|
if (ref_negative > 1) {
|
|
|
|
// Use first reference from L0
|
|
|
|
// ToDo: use better reference
|
|
|
|
WRITE_UE(stream, 0, "collocated_ref_idx");
|
|
|
|
}
|
2016-08-10 08:58:15 +00:00
|
|
|
}
|
2018-07-25 07:17:42 +00:00
|
|
|
// ToDo: VVC check num of merge cands, might be 7
|
2014-06-03 12:47:49 +00:00
|
|
|
WRITE_UE(stream, 5-MRG_MAX_NUM_CANDS, "five_minus_max_num_merge_cand");
|
|
|
|
}
|
|
|
|
|
2014-08-25 13:39:46 +00:00
|
|
|
{
|
2017-02-05 09:59:21 +00:00
|
|
|
int slice_qp_delta = state->frame->QP - encoder->cfg.qp;
|
2014-08-25 13:39:46 +00:00
|
|
|
WRITE_SE(stream, slice_qp_delta, "slice_qp_delta");
|
|
|
|
}
|
2017-01-31 13:11:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void kvz_encoder_state_write_bitstream_slice_header(
|
|
|
|
struct bitstream_t * const stream,
|
|
|
|
struct encoder_state_t * const state,
|
|
|
|
bool independent)
|
|
|
|
{
|
|
|
|
const encoder_control_t * const encoder = state->encoder_control;
|
|
|
|
|
|
|
|
#ifdef KVZ_DEBUG
|
|
|
|
printf("=========== Slice ===========\n");
|
|
|
|
#endif
|
|
|
|
|
|
|
|
bool first_slice_segment_in_pic = (state->slice->start_in_rs == 0);
|
2017-02-05 09:59:21 +00:00
|
|
|
if ((state->encoder_control->cfg.slices & KVZ_SLICES_WPP)
|
2017-01-31 13:44:23 +00:00
|
|
|
&& state->wfrow->lcu_offset_y > 0)
|
|
|
|
{
|
|
|
|
first_slice_segment_in_pic = false;
|
|
|
|
}
|
2017-01-31 13:11:50 +00:00
|
|
|
|
|
|
|
WRITE_U(stream, first_slice_segment_in_pic, 1, "first_slice_segment_in_pic_flag");
|
|
|
|
|
|
|
|
if (state->frame->pictype >= KVZ_NAL_BLA_W_LP
|
|
|
|
&& state->frame->pictype <= KVZ_NAL_RSV_IRAP_VCL23) {
|
|
|
|
WRITE_U(stream, 0, 1, "no_output_of_prior_pics_flag");
|
|
|
|
}
|
|
|
|
|
|
|
|
WRITE_UE(stream, 0, "slice_pic_parameter_set_id");
|
|
|
|
|
|
|
|
if (!first_slice_segment_in_pic) {
|
2018-07-25 07:17:42 +00:00
|
|
|
/*
|
2017-01-31 13:11:50 +00:00
|
|
|
if (encoder->pps.dependent_slice_segments_enabled_flag) {
|
|
|
|
WRITE_U(stream, !independent, 1, "dependent_slice_segment_flag");
|
|
|
|
}
|
2018-07-25 07:17:42 +00:00
|
|
|
*/
|
2017-01-31 13:11:50 +00:00
|
|
|
|
|
|
|
int lcu_cnt = encoder->in.width_in_lcu * encoder->in.height_in_lcu;
|
|
|
|
int num_bits = kvz_math_ceil_log2(lcu_cnt);
|
|
|
|
int slice_start_rs = state->slice->start_in_rs;
|
2017-02-05 09:59:21 +00:00
|
|
|
if (state->encoder_control->cfg.slices & KVZ_SLICES_WPP) {
|
2017-01-31 13:44:23 +00:00
|
|
|
slice_start_rs += state->wfrow->lcu_offset_y * state->tile->frame->width_in_lcu;
|
|
|
|
}
|
2017-01-31 13:11:50 +00:00
|
|
|
WRITE_U(stream, slice_start_rs, num_bits, "slice_segment_address");
|
|
|
|
}
|
|
|
|
|
2018-07-25 07:17:42 +00:00
|
|
|
//if (independent) {
|
2017-01-31 13:11:50 +00:00
|
|
|
kvz_encoder_state_write_bitstream_slice_header_independent(stream, state);
|
2018-07-25 07:17:42 +00:00
|
|
|
//}
|
2018-07-25 08:19:53 +00:00
|
|
|
/*
|
2017-02-06 11:00:25 +00:00
|
|
|
if (encoder->tiles_enable || encoder->cfg.wpp) {
|
2014-06-03 12:47:49 +00:00
|
|
|
int num_entry_points = 0;
|
|
|
|
int max_length_seen = 0;
|
|
|
|
|
2017-01-31 12:01:59 +00:00
|
|
|
if (state->is_leaf) {
|
|
|
|
num_entry_points = 1;
|
|
|
|
} else {
|
2016-09-30 11:59:47 +00:00
|
|
|
encoder_state_entry_points_explore(state, &num_entry_points, &max_length_seen);
|
2017-01-31 12:01:59 +00:00
|
|
|
}
|
2014-06-03 12:47:49 +00:00
|
|
|
|
2017-01-31 12:01:59 +00:00
|
|
|
int num_offsets = num_entry_points - 1;
|
|
|
|
|
|
|
|
WRITE_UE(stream, num_offsets, "num_entry_point_offsets");
|
|
|
|
if (num_offsets > 0) {
|
2014-06-03 12:47:49 +00:00
|
|
|
int entry_points_written = 0;
|
2016-03-10 13:28:31 +00:00
|
|
|
int offset_len = kvz_math_floor_log2(max_length_seen) + 1;
|
2014-06-03 12:47:49 +00:00
|
|
|
WRITE_UE(stream, offset_len - 1, "offset_len_minus1");
|
2015-03-04 15:00:23 +00:00
|
|
|
encoder_state_write_bitstream_entry_points_write(stream, state, num_entry_points, offset_len, &entry_points_written);
|
2014-06-03 12:47:49 +00:00
|
|
|
}
|
|
|
|
}
|
2018-07-25 08:19:53 +00:00
|
|
|
*/
|
2014-06-03 12:47:49 +00:00
|
|
|
}
|
|
|
|
|
2014-06-04 14:45:46 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* \brief Add a checksum SEI message to the bitstream.
|
|
|
|
* \param encoder The encoder.
|
|
|
|
* \returns Void
|
|
|
|
*/
|
2015-03-04 15:00:23 +00:00
|
|
|
static void add_checksum(encoder_state_t * const state)
|
2014-06-04 14:45:46 +00:00
|
|
|
{
|
2015-03-04 15:00:23 +00:00
|
|
|
bitstream_t * const stream = &state->stream;
|
|
|
|
const videoframe_t * const frame = state->tile->frame;
|
2014-06-04 14:45:46 +00:00
|
|
|
unsigned char checksum[3][SEI_HASH_MAX_LENGTH];
|
|
|
|
|
2015-09-15 07:19:31 +00:00
|
|
|
kvz_nal_write(stream, KVZ_NAL_SUFFIX_SEI_NUT, 0, 0);
|
2014-06-04 14:45:46 +00:00
|
|
|
|
|
|
|
WRITE_U(stream, 132, 8, "sei_type");
|
2016-03-17 16:12:43 +00:00
|
|
|
|
2016-08-25 13:05:46 +00:00
|
|
|
int num_colors = (state->encoder_control->chroma_format == KVZ_CSP_400 ? 1 : 3);
|
|
|
|
|
2017-02-05 09:59:21 +00:00
|
|
|
switch (state->encoder_control->cfg.hash)
|
2016-03-17 16:12:43 +00:00
|
|
|
{
|
|
|
|
case KVZ_HASH_CHECKSUM:
|
|
|
|
kvz_image_checksum(frame->rec, checksum, state->encoder_control->bitdepth);
|
|
|
|
|
2016-08-25 13:05:46 +00:00
|
|
|
WRITE_U(stream, 1 + num_colors * 4, 8, "size");
|
2016-03-17 16:12:43 +00:00
|
|
|
WRITE_U(stream, 2, 8, "hash_type"); // 2 = checksum
|
|
|
|
|
2016-08-25 13:05:46 +00:00
|
|
|
for (int i = 0; i < num_colors; ++i) {
|
2016-03-17 16:12:43 +00:00
|
|
|
uint32_t checksum_val = (
|
|
|
|
(checksum[i][0] << 24) + (checksum[i][1] << 16) +
|
|
|
|
(checksum[i][2] << 8) + (checksum[i][3]));
|
|
|
|
WRITE_U(stream, checksum_val, 32, "picture_checksum");
|
|
|
|
CHECKPOINT("checksum[%d] = %u", i, checksum_val);
|
|
|
|
}
|
|
|
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
case KVZ_HASH_MD5:
|
|
|
|
kvz_image_md5(frame->rec, checksum, state->encoder_control->bitdepth);
|
|
|
|
|
2016-08-25 13:05:46 +00:00
|
|
|
WRITE_U(stream, 1 + num_colors * 16, 8, "size");
|
2016-03-17 16:12:43 +00:00
|
|
|
WRITE_U(stream, 0, 8, "hash_type"); // 0 = md5
|
|
|
|
|
2016-08-25 13:05:46 +00:00
|
|
|
for (int i = 0; i < num_colors; ++i) {
|
2016-03-17 16:12:43 +00:00
|
|
|
for (int b = 0; b < 16; ++b) {
|
|
|
|
WRITE_U(stream, checksum[i][b], 8, "picture_md5");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
case KVZ_HASH_NONE:
|
|
|
|
// Means we shouldn't be writing this SEI.
|
|
|
|
assert(0);
|
2014-06-04 14:45:46 +00:00
|
|
|
}
|
|
|
|
|
2015-08-27 11:56:05 +00:00
|
|
|
kvz_bitstream_align(stream);
|
|
|
|
|
|
|
|
// spec:sei_rbsp() rbsp_trailing_bits
|
2015-08-27 11:33:30 +00:00
|
|
|
kvz_bitstream_add_rbsp_trailing_bits(stream);
|
2014-06-04 14:45:46 +00:00
|
|
|
}
|
|
|
|
|
2017-01-31 11:26:56 +00:00
|
|
|
static void encoder_state_write_slice_header(
|
|
|
|
bitstream_t * stream,
|
2017-01-31 13:11:50 +00:00
|
|
|
encoder_state_t * state,
|
|
|
|
bool independent)
|
2017-01-31 11:26:56 +00:00
|
|
|
{
|
2017-09-19 06:20:10 +00:00
|
|
|
kvz_nal_write(stream, state->frame->pictype, 0, state->frame->first_nal);
|
2017-01-31 11:26:56 +00:00
|
|
|
state->frame->first_nal = false;
|
|
|
|
|
2017-01-31 13:11:50 +00:00
|
|
|
kvz_encoder_state_write_bitstream_slice_header(stream, state, independent);
|
2017-01-31 11:26:56 +00:00
|
|
|
kvz_bitstream_add_rbsp_trailing_bits(stream);
|
|
|
|
}
|
|
|
|
|
2015-07-08 08:08:04 +00:00
|
|
|
/**
|
|
|
|
* \brief Move child state bitstreams to the parent stream.
|
|
|
|
*/
|
|
|
|
static void encoder_state_write_bitstream_children(encoder_state_t * const state)
|
|
|
|
{
|
2017-01-31 11:26:56 +00:00
|
|
|
// Write Slice headers to the parent stream instead of the child stream
|
|
|
|
// in case the child stream is a leaf with something in it already.
|
2015-07-08 08:08:04 +00:00
|
|
|
for (int i = 0; state->children[i].encoder_control; ++i) {
|
2017-01-31 11:26:56 +00:00
|
|
|
if (state->children[i].type == ENCODER_STATE_TYPE_SLICE) {
|
2017-01-31 13:11:50 +00:00
|
|
|
encoder_state_write_slice_header(&state->stream, &state->children[i], true);
|
2017-01-31 13:44:23 +00:00
|
|
|
} else if (state->children[i].type == ENCODER_STATE_TYPE_WAVEFRONT_ROW) {
|
2017-02-05 09:59:21 +00:00
|
|
|
if ((state->encoder_control->cfg.slices & KVZ_SLICES_WPP) && i != 0) {
|
2017-01-31 13:44:23 +00:00
|
|
|
// Add header for dependent WPP row slice.
|
|
|
|
encoder_state_write_slice_header(&state->stream, &state->children[i], false);
|
|
|
|
}
|
2017-01-31 11:26:56 +00:00
|
|
|
}
|
2015-08-26 08:50:27 +00:00
|
|
|
kvz_encoder_state_write_bitstream(&state->children[i]);
|
|
|
|
kvz_bitstream_move(&state->stream, &state->children[i].stream);
|
2015-07-08 08:08:04 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void encoder_state_write_bitstream_main(encoder_state_t * const state)
|
|
|
|
{
|
2015-03-04 15:00:23 +00:00
|
|
|
const encoder_control_t * const encoder = state->encoder_control;
|
|
|
|
bitstream_t * const stream = &state->stream;
|
2015-08-26 08:50:27 +00:00
|
|
|
uint64_t curpos = kvz_bitstream_tell(stream);
|
2014-06-03 12:47:49 +00:00
|
|
|
|
2015-01-20 15:19:14 +00:00
|
|
|
// The first NAL unit of the access unit must use a long start code.
|
2017-01-31 10:28:28 +00:00
|
|
|
state->frame->first_nal = true;
|
2015-01-20 15:19:14 +00:00
|
|
|
|
|
|
|
// Access Unit Delimiter (AUD)
|
2017-02-06 11:00:25 +00:00
|
|
|
if (encoder->cfg.aud_enable) {
|
2017-01-31 10:28:28 +00:00
|
|
|
state->frame->first_nal = false;
|
2015-03-04 15:00:23 +00:00
|
|
|
encoder_state_write_bitstream_aud(state);
|
2015-01-20 15:19:14 +00:00
|
|
|
}
|
2016-10-06 12:27:01 +00:00
|
|
|
|
|
|
|
if (encoder_state_must_write_vps(state)) {
|
2017-01-31 10:28:28 +00:00
|
|
|
state->frame->first_nal = false;
|
2015-10-14 10:47:23 +00:00
|
|
|
kvz_encoder_state_write_parameter_sets(&state->stream, state);
|
2015-01-22 11:13:23 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Send Kvazaar version information only in the first frame.
|
2017-02-05 09:59:21 +00:00
|
|
|
if (state->frame->num == 0 && encoder->cfg.add_encoder_info) {
|
2017-01-31 10:28:28 +00:00
|
|
|
kvz_nal_write(stream, KVZ_NAL_PREFIX_SEI_NUT, 0, state->frame->first_nal);
|
|
|
|
state->frame->first_nal = false;
|
2015-03-04 15:00:23 +00:00
|
|
|
encoder_state_write_bitstream_prefix_sei_version(state);
|
2015-08-27 11:56:05 +00:00
|
|
|
|
|
|
|
// spec:sei_rbsp() rbsp_trailing_bits
|
2015-08-27 11:33:30 +00:00
|
|
|
kvz_bitstream_add_rbsp_trailing_bits(stream);
|
2014-06-03 12:47:49 +00:00
|
|
|
}
|
|
|
|
|
2015-04-08 14:17:45 +00:00
|
|
|
//SEI messages for interlacing
|
2017-01-31 10:28:28 +00:00
|
|
|
if (encoder->vui.frame_field_info_present_flag) {
|
2015-04-08 14:17:45 +00:00
|
|
|
// These should be optional, needed for earlier versions
|
|
|
|
// of HM decoder to accept bitstream
|
2015-09-15 07:19:31 +00:00
|
|
|
//kvz_nal_write(stream, KVZ_NAL_PREFIX_SEI_NUT, 0, 0);
|
2015-04-08 14:17:45 +00:00
|
|
|
//encoder_state_write_active_parameter_sets_sei_message(state);
|
2015-08-27 11:33:30 +00:00
|
|
|
//kvz_bitstream_rbsp_trailing_bits(stream);
|
2015-04-08 14:17:45 +00:00
|
|
|
|
2017-01-31 10:28:28 +00:00
|
|
|
kvz_nal_write(stream, KVZ_NAL_PREFIX_SEI_NUT, 0, state->frame->first_nal);
|
|
|
|
state->frame->first_nal = false;
|
2015-04-08 14:17:45 +00:00
|
|
|
encoder_state_write_picture_timing_sei_message(state);
|
2015-08-27 11:56:05 +00:00
|
|
|
|
|
|
|
// spec:sei_rbsp() rbsp_trailing_bits
|
2015-08-27 11:33:30 +00:00
|
|
|
kvz_bitstream_add_rbsp_trailing_bits(stream);
|
2015-04-08 14:17:45 +00:00
|
|
|
}
|
|
|
|
|
2017-07-20 12:18:30 +00:00
|
|
|
encoder_state_write_bitstream_children(state);
|
|
|
|
|
2017-02-05 09:59:21 +00:00
|
|
|
if (state->encoder_control->cfg.hash != KVZ_HASH_NONE) {
|
2014-06-03 12:47:49 +00:00
|
|
|
// Calculate checksum
|
2015-03-04 15:00:23 +00:00
|
|
|
add_checksum(state);
|
2014-06-03 12:47:49 +00:00
|
|
|
}
|
2017-07-20 12:18:30 +00:00
|
|
|
|
2014-06-19 08:23:01 +00:00
|
|
|
//Get bitstream length for stats
|
2015-08-26 08:50:27 +00:00
|
|
|
uint64_t newpos = kvz_bitstream_tell(stream);
|
2015-04-17 14:31:22 +00:00
|
|
|
state->stats_bitstream_length = (newpos >> 3) - (curpos >> 3);
|
2015-04-29 11:24:33 +00:00
|
|
|
|
2016-08-10 00:46:23 +00:00
|
|
|
if (state->frame->num > 0) {
|
|
|
|
state->frame->total_bits_coded = state->previous_encoder_state->frame->total_bits_coded;
|
2015-04-17 14:31:22 +00:00
|
|
|
}
|
2016-08-10 00:46:23 +00:00
|
|
|
state->frame->total_bits_coded += newpos - curpos;
|
2015-01-22 09:53:12 +00:00
|
|
|
|
2016-09-30 11:59:47 +00:00
|
|
|
state->frame->cur_gop_bits_coded = state->previous_encoder_state->frame->cur_gop_bits_coded;
|
2016-08-10 00:46:23 +00:00
|
|
|
state->frame->cur_gop_bits_coded += newpos - curpos;
|
2014-06-03 12:47:49 +00:00
|
|
|
}
|
|
|
|
|
2015-08-26 08:50:27 +00:00
|
|
|
void kvz_encoder_state_write_bitstream(encoder_state_t * const state)
|
2015-07-08 08:08:04 +00:00
|
|
|
{
|
2015-03-04 15:00:23 +00:00
|
|
|
if (!state->is_leaf) {
|
|
|
|
switch (state->type) {
|
2014-06-03 12:47:49 +00:00
|
|
|
case ENCODER_STATE_TYPE_MAIN:
|
2015-03-04 15:00:23 +00:00
|
|
|
encoder_state_write_bitstream_main(state);
|
2014-06-03 12:47:49 +00:00
|
|
|
break;
|
|
|
|
case ENCODER_STATE_TYPE_TILE:
|
|
|
|
case ENCODER_STATE_TYPE_SLICE:
|
2017-01-31 11:26:56 +00:00
|
|
|
encoder_state_write_bitstream_children(state);
|
2014-06-03 12:47:49 +00:00
|
|
|
break;
|
|
|
|
default:
|
2015-03-04 15:00:23 +00:00
|
|
|
fprintf(stderr, "Unsupported node type %c!\n", state->type);
|
2014-06-03 12:47:49 +00:00
|
|
|
assert(0);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-08-26 08:50:27 +00:00
|
|
|
void kvz_encoder_state_worker_write_bitstream(void * opaque)
|
2015-07-08 08:08:04 +00:00
|
|
|
{
|
2015-08-26 08:50:27 +00:00
|
|
|
kvz_encoder_state_write_bitstream((encoder_state_t *) opaque);
|
2014-06-13 09:30:08 +00:00
|
|
|
}
|
2015-10-14 10:47:23 +00:00
|
|
|
|
|
|
|
void kvz_encoder_state_write_parameter_sets(bitstream_t *stream,
|
|
|
|
encoder_state_t * const state)
|
|
|
|
{
|
|
|
|
// Video Parameter Set (VPS)
|
2018-07-25 08:02:09 +00:00
|
|
|
/*
|
2015-10-14 10:47:23 +00:00
|
|
|
kvz_nal_write(stream, KVZ_NAL_VPS_NUT, 0, 1);
|
|
|
|
encoder_state_write_bitstream_vid_parameter_set(stream, state);
|
2018-07-25 08:02:09 +00:00
|
|
|
*/
|
2015-10-14 10:47:23 +00:00
|
|
|
|
|
|
|
// Sequence Parameter Set (SPS)
|
|
|
|
kvz_nal_write(stream, KVZ_NAL_SPS_NUT, 0, 1);
|
|
|
|
encoder_state_write_bitstream_seq_parameter_set(stream, state);
|
|
|
|
|
|
|
|
// Picture Parameter Set (PPS)
|
|
|
|
kvz_nal_write(stream, KVZ_NAL_PPS_NUT, 0, 1);
|
|
|
|
encoder_state_write_bitstream_pic_parameter_set(stream, state);
|
|
|
|
}
|