Пример #1
0
void
xavs_pb_picture_write (bs_t * s, xavs_pb_pic_header_t * pbh, xavs_seq_header_t * sqh)
{
  bs_write (s, 8, pbh->i_pb_picture_start_code);
  bs_write (s, 16, pbh->i_bbv_delay);
  bs_write (s, 2, pbh->i_picture_coding_type);
  bs_write (s, 8, pbh->i_picture_distance);
  if (sqh->b_low_delay)
    bs_write_ue (s, 1);         //pbh->i_bbv_check_times);
  bs_write1 (s, 1);             //pbh->b_progressive_frame);
  /*if(!pbh->b_progressive_frame){
     bs_write1( s, pbh->b_picture_structure);
     if(!pbh->b_picture_structure)
     bs_write1( s, pbh->b_advanced_pred_mode_disable);
     } */
  bs_write1 (s, 0);             //pbh->b_top_field_first);
  bs_write1 (s, 0);             //pbh->b_repeat_first_field);
  bs_write1 (s, pbh->b_fixed_picture_qp);
  bs_write (s, 6, pbh->i_picture_qp);
  if (pbh->i_picture_coding_type == 1)
    bs_write1 (s, pbh->b_picture_reference_flag);
  //bs_write1( s, pbh->b_no_forward_reference_flag);
  bs_write (s, 4, 0);           //reserved bits
  bs_write1 (s, 1);             //pbh->b_skip_mode_flag);
  bs_write1 (s, pbh->b_loop_filter_disable);
  if (!pbh->b_loop_filter_disable)
    bs_write1 (s, pbh->b_loop_filter_parameter_flag);
  if (pbh->b_loop_filter_parameter_flag)
  {
    bs_write_se (s, pbh->i_alpha_c_offset);
    bs_write_se (s, pbh->i_beta_offset);
  }
  bs_rbsp_trailing (s);
}
Пример #2
0
static void scaling_list_write( bs_t *s, x264_pps_t *pps, int idx )
{
    const int len = idx<4 ? 16 : 64;
    const uint8_t *zigzag = idx<4 ? x264_zigzag_scan4[0] : x264_zigzag_scan8[0];
    const uint8_t *list = pps->scaling_list[idx];
    const uint8_t *def_list = (idx==CQM_4IC) ? pps->scaling_list[CQM_4IY]
                            : (idx==CQM_4PC) ? pps->scaling_list[CQM_4PY]
                            : x264_cqm_jvt[idx];
    if( !memcmp( list, def_list, len ) )
        bs_write( s, 1, 0 ); // scaling_list_present_flag
    else if( !memcmp( list, x264_cqm_jvt[idx], len ) )
    {
        bs_write( s, 1, 1 ); // scaling_list_present_flag
        bs_write_se( s, -8 ); // use jvt list
    }
    else
    {
        int j, run;
        bs_write( s, 1, 1 ); // scaling_list_present_flag

        // try run-length compression of trailing values
        for( run = len; run > 1; run-- )
            if( list[zigzag[run-1]] != list[zigzag[run-2]] )
                break;
        if( run < len && len - run < bs_size_se( (int8_t)-list[zigzag[run]] ) )
            run = len;

        for( j = 0; j < run; j++ )
            bs_write_se( s, (int8_t)(list[zigzag[j]] - (j>0 ? list[zigzag[j-1]] : 8)) ); // delta

        if( run < len )
            bs_write_se( s, (int8_t)-list[zigzag[run]] );
    }
}
Пример #3
0
void
xavs_i_picture_write (bs_t * s, xavs_i_pic_header_t * ih, xavs_seq_header_t * sqh)
{
  bs_write (s, 8, 0xB3);        //ih->i_i_picture_start_code);
  bs_write (s, 16, ih->i_bbv_delay);
  bs_write1 (s, ih->b_time_code_flag);
  if (ih->b_time_code_flag)
    bs_write (s, 24, ih->i_time_code);
  bs_write1 (s, 1);             //marker bit
  bs_write (s, 8, ih->i_picture_distance);
  if (sqh->b_low_delay)
    bs_write_ue (s, 1);         //ih->i_bbv_check_times);
  bs_write1 (s, ih->b_progressive_frame);
  if (!ih->b_progressive_frame)
    bs_write1 (s, ih->b_picture_structure);

  bs_write1 (s, 1);             //ih->b_top_field_first);
  bs_write1 (s, 0);             //ih->b_repeat_first_field);
  bs_write1 (s, ih->b_fixed_picture_qp);
  bs_write (s, 6, ih->i_picture_qp);
  //if(!ih->b_progressive_frame && !ih->b_picture_structure)
  //bs_write1( s, ih->b_skip_mode_flag);
  bs_write (s, 4, ih->i_reserved_bits);
  bs_write1 (s, ih->b_loop_filter_disable);
  if (!ih->b_loop_filter_disable)
    bs_write1 (s, ih->b_loop_filter_parameter_flag);
  if (ih->b_loop_filter_parameter_flag)
  {
    bs_write_se (s, ih->i_alpha_c_offset);
    bs_write_se (s, ih->i_beta_offset);
  }
  bs_rbsp_trailing (s);
}
Пример #4
0
//7.3.2.1.1 Scaling list syntax
void write_scaling_list(bs_t* b, int* scalingList, int sizeOfScalingList, int useDefaultScalingMatrixFlag)
{
	int j;

	int lastScale = 8;
	int nextScale = 8;

	for (j = 0; j < sizeOfScalingList; j++)
	{
		int delta_scale;

		if (nextScale != 0)
		{
			// FIXME will not write in most compact way - could truncate list if all remaining elements are equal
			nextScale = scalingList[j];

			if (useDefaultScalingMatrixFlag)
			{
				nextScale = 0;
			}

			delta_scale = (nextScale - lastScale) % 256;
			bs_write_se(b, delta_scale);
		}

		lastScale = scalingList[j];
	}
}
Пример #5
0
void x264_pps_write( bs_t *s, x264_pps_t *pps )
{
    bs_realign( s );
    bs_write_ue( s, pps->i_id );
    bs_write_ue( s, pps->i_sps_id );

    bs_write1( s, pps->b_cabac );
    bs_write1( s, pps->b_pic_order );
    bs_write_ue( s, pps->i_num_slice_groups - 1 );

    bs_write_ue( s, pps->i_num_ref_idx_l0_default_active - 1 );
    bs_write_ue( s, pps->i_num_ref_idx_l1_default_active - 1 );
    bs_write1( s, pps->b_weighted_pred );
    bs_write( s, 2, pps->b_weighted_bipred );

    bs_write_se( s, pps->i_pic_init_qp - 26 - QP_BD_OFFSET );
    bs_write_se( s, pps->i_pic_init_qs - 26 - QP_BD_OFFSET );
    bs_write_se( s, pps->i_chroma_qp_index_offset );

    bs_write1( s, pps->b_deblocking_filter_control );
    bs_write1( s, pps->b_constrained_intra_pred );
    bs_write1( s, pps->b_redundant_pic_cnt );

    if( pps->b_transform_8x8_mode || pps->i_cqm_preset != X264_CQM_FLAT )
    {
        bs_write1( s, pps->b_transform_8x8_mode );
        bs_write1( s, (pps->i_cqm_preset != X264_CQM_FLAT) );
        if( pps->i_cqm_preset != X264_CQM_FLAT )
        {
            scaling_list_write( s, pps, CQM_4IY );
            scaling_list_write( s, pps, CQM_4IC );
            bs_write1( s, 0 ); // Cr = Cb
            scaling_list_write( s, pps, CQM_4PY );
            scaling_list_write( s, pps, CQM_4PC );
            bs_write1( s, 0 ); // Cr = Cb
            if( pps->b_transform_8x8_mode )
            {
                scaling_list_write( s, pps, CQM_8IY+4 );
                scaling_list_write( s, pps, CQM_8PY+4 );
            }
        }
        bs_write_se( s, pps->i_chroma_qp_index_offset );
    }

    bs_rbsp_trailing( s );
    bs_flush( s );
}
Пример #6
0
static void scaling_list_write( bs_t *s, x264_pps_t *pps, int idx )
{
    const int len = idx<4 ? 16 : 64;
    const int *zigzag = idx<4 ? x264_zigzag_scan4 : x264_zigzag_scan8;
    const uint8_t *list = pps->scaling_list[idx];
    const uint8_t *def_list = (idx==CQM_4IC) ? pps->scaling_list[CQM_4IY]
                            : (idx==CQM_4PC) ? pps->scaling_list[CQM_4PY]
                            : x264_cqm_jvt[idx];
    int j;
    if( memcmp( list, def_list, len ) )
    {
        bs_write( s, 1, 1 ); // scaling_list_present_flag
        for( j = 0; j < len; j++ )
            bs_write_se( s, list[zigzag[j]] - (j>0 ? list[zigzag[j-1]] : 8) ); // delta
    }
    else
        bs_write( s, 1, 0 ); // scaling_list_present_flag
}
Пример #7
0
void x264_sps_write( bs_t *s, x264_sps_t *sps )
{
    bs_write( s, 8, sps->i_profile_idc );
    bs_write( s, 1, sps->b_constraint_set0 );
    bs_write( s, 1, sps->b_constraint_set1 );
    bs_write( s, 1, sps->b_constraint_set2 );

    bs_write( s, 5, 0 );    /* reserved */

    bs_write( s, 8, sps->i_level_idc );

    bs_write_ue( s, sps->i_id );

    if( sps->i_profile_idc >= PROFILE_HIGH )
    {
        bs_write_ue( s, 1 ); // chroma_format_idc = 4:2:0
        bs_write_ue( s, 0 ); // bit_depth_luma_minus8
        bs_write_ue( s, 0 ); // bit_depth_chroma_minus8
        bs_write( s, 1, sps->b_qpprime_y_zero_transform_bypass );
        bs_write( s, 1, 0 ); // seq_scaling_matrix_present_flag
    }

    bs_write_ue( s, sps->i_log2_max_frame_num - 4 );
    bs_write_ue( s, sps->i_poc_type );
    if( sps->i_poc_type == 0 )
    {
        bs_write_ue( s, sps->i_log2_max_poc_lsb - 4 );
    }
    else if( sps->i_poc_type == 1 )
    {
        int i;

        bs_write( s, 1, sps->b_delta_pic_order_always_zero );
        bs_write_se( s, sps->i_offset_for_non_ref_pic );
        bs_write_se( s, sps->i_offset_for_top_to_bottom_field );
        bs_write_ue( s, sps->i_num_ref_frames_in_poc_cycle );

        for( i = 0; i < sps->i_num_ref_frames_in_poc_cycle; i++ )
        {
            bs_write_se( s, sps->i_offset_for_ref_frame[i] );
        }
    }
    bs_write_ue( s, sps->i_num_ref_frames );
    bs_write( s, 1, sps->b_gaps_in_frame_num_value_allowed );
    bs_write_ue( s, sps->i_mb_width - 1 );
    if (sps->b_frame_mbs_only)
    {
        bs_write_ue( s, sps->i_mb_height - 1);
    }
    else // interlaced
    {
        bs_write_ue( s, sps->i_mb_height/2 - 1);
    }
    bs_write( s, 1, sps->b_frame_mbs_only );
    if( !sps->b_frame_mbs_only )
    {
        bs_write( s, 1, sps->b_mb_adaptive_frame_field );
    }
    bs_write( s, 1, sps->b_direct8x8_inference );

    bs_write( s, 1, sps->b_crop );
    if( sps->b_crop )
    {
        bs_write_ue( s, sps->crop.i_left   / 2 );
        bs_write_ue( s, sps->crop.i_right  / 2 );
        bs_write_ue( s, sps->crop.i_top    / 2 );
        bs_write_ue( s, sps->crop.i_bottom / 2 );
    }

    bs_write( s, 1, sps->b_vui );
    if( sps->b_vui )
    {
        bs_write1( s, sps->vui.b_aspect_ratio_info_present );
        if( sps->vui.b_aspect_ratio_info_present )
        {
            int i;
            static const struct { int w, h; int sar; } sar[] =
            {
                { 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}, { 0, 0, -1 }
            };
            for( i = 0; sar[i].sar != -1; i++ )
            {
                if( sar[i].w == sps->vui.i_sar_width &&
                    sar[i].h == sps->vui.i_sar_height )
                    break;
            }
            if( sar[i].sar != -1 )
            {
                bs_write( s, 8, sar[i].sar );
            }
            else
            {
                bs_write( s, 8, 255);   /* aspect_ratio_idc (extended) */
                bs_write( s, 16, sps->vui.i_sar_width );
                bs_write( s, 16, sps->vui.i_sar_height );
            }
        }

        bs_write1( s, sps->vui.b_overscan_info_present );
        if( sps->vui.b_overscan_info_present )
            bs_write1( s, sps->vui.b_overscan_info );

        bs_write1( s, sps->vui.b_signal_type_present );
        if( sps->vui.b_signal_type_present )
        {
            bs_write( s, 3, sps->vui.i_vidformat );
            bs_write1( s, sps->vui.b_fullrange );
            bs_write1( s, sps->vui.b_color_description_present );
            if( sps->vui.b_color_description_present )
            {
                bs_write( s, 8, sps->vui.i_colorprim );
                bs_write( s, 8, sps->vui.i_transfer );
                bs_write( s, 8, sps->vui.i_colmatrix );
            }
        }

        bs_write1( s, sps->vui.b_chroma_loc_info_present );
        if( sps->vui.b_chroma_loc_info_present )
        {
            bs_write_ue( s, sps->vui.i_chroma_loc_top );
            bs_write_ue( s, sps->vui.i_chroma_loc_bottom );
        }

        bs_write1( s, sps->vui.b_timing_info_present );
        if( sps->vui.b_timing_info_present )
        {
            bs_write32( s, sps->vui.i_num_units_in_tick );
            bs_write32( s, sps->vui.i_time_scale );
            bs_write1( s, sps->vui.b_fixed_frame_rate );
        }

        bs_write1( s, 0 );      /* nal_hrd_parameters_present_flag */
        bs_write1( s, 0 );      /* vcl_hrd_parameters_present_flag */
        bs_write1( s, 0 );      /* pic_struct_present_flag */
        bs_write1( s, sps->vui.b_bitstream_restriction );
        if( sps->vui.b_bitstream_restriction )
        {
            bs_write1( s, sps->vui.b_motion_vectors_over_pic_boundaries );
            bs_write_ue( s, sps->vui.i_max_bytes_per_pic_denom );
            bs_write_ue( s, sps->vui.i_max_bits_per_mb_denom );
            bs_write_ue( s, sps->vui.i_log2_max_mv_length_horizontal );
            bs_write_ue( s, sps->vui.i_log2_max_mv_length_vertical );
            bs_write_ue( s, sps->vui.i_num_reorder_frames );
            bs_write_ue( s, sps->vui.i_max_dec_frame_buffering );
        }
    }

    bs_rbsp_trailing( s );
}
Пример #8
0
void x264_pps_write( bs_t *s, x264_pps_t *pps )
{
    bs_write_ue( s, pps->i_id );
    bs_write_ue( s, pps->i_sps_id );

    bs_write( s, 1, pps->b_cabac );
    bs_write( s, 1, pps->b_pic_order );
    bs_write_ue( s, pps->i_num_slice_groups - 1 );

#if 0
    if( pps->i_num_slice_groups > 1 )
    {
        int i;

        bs_write_ue( s, pps->i_slice_group_map_type );
        if( pps->i_slice_group_map_type == 0 )
        {
            for( i = 0; i < pps->i_num_slice_groups; i++ )
            {
                bs_write_ue( s, pps->i_run_length[i] - 1 );
            }
        }
        else if( pps->i_slice_group_map_type == 2 )
        {
            for( i = 0; i < pps->i_num_slice_groups; i++ )
            {
                bs_write_ue( s, pps->i_top_left[i] );
                bs_write_ue( s, pps->i_bottom_right[i] );
            }
        }
        else if( pps->i_slice_group_map_type >= 3 &&
                 pps->i_slice_group_map_type <= 5 )
        {
            bs_write( s, 1, pps->b_slice_group_change_direction );
            bs_write_ue( s, pps->b_slice_group_change_direction - 1 );
        }
        else if( pps->i_slice_group_map_type == 6 )
        {
            bs_write_ue( s, pps->i_pic_size_in_map_units - 1 );
            for( i = 0; i < pps->i_pic_size_in_map_units; i++ )
            {
                /* FIXME */
                /* bs_write( s, ceil( log2( pps->i_pic_size_in_map_units +1 ) ),
                 *              pps->i_slice_group_id[i] );
                 */
            }
        }
    }
#endif

    bs_write_ue( s, pps->i_num_ref_idx_l0_active - 1 );
    bs_write_ue( s, pps->i_num_ref_idx_l1_active - 1 );
    bs_write( s, 1, pps->b_weighted_pred );
    bs_write( s, 2, pps->b_weighted_bipred );

    bs_write_se( s, pps->i_pic_init_qp - 26 );
    bs_write_se( s, pps->i_pic_init_qs - 26 );
    bs_write_se( s, pps->i_chroma_qp_index_offset );

    bs_write( s, 1, pps->b_deblocking_filter_control );
    bs_write( s, 1, pps->b_constrained_intra_pred );
    bs_write( s, 1, pps->b_redundant_pic_cnt );

    if( pps->b_transform_8x8_mode || pps->i_cqm_preset != X264_CQM_FLAT )
    {
        bs_write( s, 1, pps->b_transform_8x8_mode );
        bs_write( s, 1, (pps->i_cqm_preset != X264_CQM_FLAT) );
        if( pps->i_cqm_preset != X264_CQM_FLAT )
        {
            scaling_list_write( s, pps, CQM_4IY );
            scaling_list_write( s, pps, CQM_4IC );
            bs_write( s, 1, 0 ); // Cr = Cb
            scaling_list_write( s, pps, CQM_4PY );
            scaling_list_write( s, pps, CQM_4PC );
            bs_write( s, 1, 0 ); // Cr = Cb
            if( pps->b_transform_8x8_mode )
            {
                scaling_list_write( s, pps, CQM_8IY+4 );
                scaling_list_write( s, pps, CQM_8PY+4 );
            }
        }
        bs_write_se( s, pps->i_chroma_qp_index_offset );
    }

    bs_rbsp_trailing( s );
}
Пример #9
0
//7.3.2.1 Sequence parameter set RBSP syntax
void write_seq_parameter_set_rbsp(sps_t *sps, bs_t* b)
{
	int i;

	bs_write(b, 8, sps->profile_idc);
	bs_write(b, 1, sps->constraint_set0_flag);
	bs_write(b, 1, sps->constraint_set1_flag);
	bs_write(b, 1, sps->constraint_set2_flag);
	bs_write(b, 1, sps->constraint_set3_flag);
	bs_write(b, 1, sps->constraint_set4_flag);
	bs_write(b, 1, sps->constraint_set5_flag);
	bs_write(b, 2, 0);  /* reserved_zero_2bits */
	bs_write(b, 8, sps->level_idc);
	bs_write_ue(b, sps->seq_parameter_set_id);
	if (sps->profile_idc == 100 || sps->profile_idc == 110 ||
		sps->profile_idc == 122 || sps->profile_idc == 144)
	{
		bs_write_ue(b, sps->chroma_format_idc);
		if (sps->chroma_format_idc == 3)
		{
			bs_write(b, 1, sps->residual_colour_transform_flag);
		}
		bs_write_ue(b, sps->bit_depth_luma_minus8);
		bs_write_ue(b, sps->bit_depth_chroma_minus8);
		bs_write(b, 1, sps->qpprime_y_zero_transform_bypass_flag);
		bs_write(b, 1, sps->seq_scaling_matrix_present_flag);
		if (sps->seq_scaling_matrix_present_flag)
		{
			for (i = 0; i < 8; i++)
			{
				bs_write(b, 1, sps->seq_scaling_list_present_flag[i]);
				if (sps->seq_scaling_list_present_flag[i])
				{
					if (i < 6)
					{
						write_scaling_list(b, sps->ScalingList4x4[i], 16,
							sps->UseDefaultScalingMatrix4x4Flag[i]);
					}
					else
					{
						write_scaling_list(b, sps->ScalingList8x8[i - 6], 64,
							sps->UseDefaultScalingMatrix8x8Flag[i - 6]);
					}
				}
			}
		}
	}
	bs_write_ue(b, sps->log2_max_frame_num_minus4);
	bs_write_ue(b, sps->pic_order_cnt_type);
	if (sps->pic_order_cnt_type == 0)
	{
		bs_write_ue(b, sps->log2_max_pic_order_cnt_lsb_minus4);
	}
	else if (sps->pic_order_cnt_type == 1)
	{
		bs_write(b, 1, sps->delta_pic_order_always_zero_flag);
		bs_write_se(b, sps->offset_for_non_ref_pic);
		bs_write_se(b, sps->offset_for_top_to_bottom_field);
		bs_write_ue(b, sps->num_ref_frames_in_pic_order_cnt_cycle);
		for (i = 0; i < sps->num_ref_frames_in_pic_order_cnt_cycle; i++)
		{
			bs_write_se(b, sps->offset_for_ref_frame[i]);
		}
	}
	bs_write_ue(b, sps->num_ref_frames);
	bs_write(b, 1, sps->gaps_in_frame_num_value_allowed_flag);
	bs_write_ue(b, sps->pic_width_in_mbs_minus1);
	bs_write_ue(b, sps->pic_height_in_map_units_minus1);
	bs_write(b, 1, sps->frame_mbs_only_flag);
	if (!sps->frame_mbs_only_flag)
	{
		bs_write(b, 1, sps->mb_adaptive_frame_field_flag);
	}
	bs_write(b, 1, sps->direct_8x8_inference_flag);
	bs_write(b, 1, sps->frame_cropping_flag);
	if (sps->frame_cropping_flag)
	{
		bs_write_ue(b, sps->frame_crop_left_offset);
		bs_write_ue(b, sps->frame_crop_right_offset);
		bs_write_ue(b, sps->frame_crop_top_offset);
		bs_write_ue(b, sps->frame_crop_bottom_offset);
	}
	bs_write(b, 1, sps->vui_parameters_present_flag);
	if (sps->vui_parameters_present_flag)
	{
		write_vui_parameters(sps, b);
	}
	write_rbsp_trailing_bits(b);
}