vdpau_video.c

nvidia VDPAU 驱动与intel VAAPI 驱动桥接的接口实现。 VAAPI intel 视频解码驱动接口函数库 VDPAU：nvdia视频解码驱动接口函数库

    return driver_data->vdp_vtable.vdp_presentation_queue_target_create_x11(device,
									    drawable,
									    target);
}

// VdpPresentationQueueTargetDestroy
static inline VdpStatus
vdpau_presentation_queue_target_destroy(vdpau_driver_data_t       *driver_data,
					VdpPresentationQueueTarget presentation_queue_target)
{
    if (driver_data == NULL)
	return VDP_STATUS_INVALID_POINTER;
    if (driver_data->vdp_vtable.vdp_presentation_queue_target_destroy == NULL)
	return VDP_STATUS_INVALID_POINTER;
    return driver_data->vdp_vtable.vdp_presentation_queue_target_destroy(presentation_queue_target);
}

// VdpDecoderCreate
static inline VdpStatus
vdpau_decoder_create(vdpau_driver_data_t *driver_data,
		     VdpDevice            device,
		     VdpDecoderProfile    profile,
		     uint32_t             width,
		     uint32_t             height,
		     uint32_t             max_references,
		     VdpDecoder          *decoder)
{
    if (driver_data == NULL)
	return VDP_STATUS_INVALID_POINTER;
    if (driver_data->vdp_vtable.vdp_decoder_create == NULL)
	return VDP_STATUS_INVALID_POINTER;
    return driver_data->vdp_vtable.vdp_decoder_create(device,
						      profile,
						      width,
						      height,
						      max_references,
						      decoder);
}

// VdpDecoderDestroy
static inline VdpStatus
vdpau_decoder_destroy(vdpau_driver_data_t *driver_data,
		      VdpDecoder           decoder)
{
    if (driver_data == NULL)
	return VDP_STATUS_INVALID_POINTER;
    if (driver_data->vdp_vtable.vdp_decoder_destroy == NULL)
	return VDP_STATUS_INVALID_POINTER;
    return driver_data->vdp_vtable.vdp_decoder_destroy(decoder);
}

// VdpDecoderRender
static inline VdpStatus
vdpau_decoder_render(vdpau_driver_data_t      *driver_data,
		     VdpDecoder                decoder,
		     VdpVideoSurface           target,
		     VdpPictureInfo const     *picture_info,
		     uint32_t                  bitstream_buffers_count,
		     VdpBitstreamBuffer const *bitstream_buffers)
		     
{
    if (driver_data == NULL)
	return VDP_STATUS_INVALID_POINTER;
    if (driver_data->vdp_vtable.vdp_decoder_render == NULL)
	return VDP_STATUS_INVALID_POINTER;
    return driver_data->vdp_vtable.vdp_decoder_render(decoder,
						      target,
						      picture_info,
						      bitstream_buffers_count,
						      bitstream_buffers);
}

// VdpDecoderQueryCapabilities
static inline VdpStatus
vdpau_decoder_query_capabilities(vdpau_driver_data_t *driver_data,
				 VdpDevice            device,
				 VdpDecoderProfile    profile,
				 VdpBool             *is_supported,
				 uint32_t            *max_level,
				 uint32_t            *max_references,
				 uint32_t            *max_width,
				 uint32_t            *max_height)
{
    if (driver_data == NULL)
	return VDP_STATUS_INVALID_POINTER;
    if (driver_data->vdp_vtable.vdp_decoder_query_capabilities == NULL)
	return VDP_STATUS_INVALID_POINTER;
    return driver_data->vdp_vtable.vdp_decoder_query_capabilities(device,
								  profile,
								  is_supported,
								  max_level,
								  max_references,
								  max_width,
								  max_height);
}

// VdpVideoSurfaceQueryGetPutBitsYCbCrCapabilities
static inline VdpStatus
vdpau_video_surface_query_ycbcr_caps(vdpau_driver_data_t *driver_data,
				     VdpDevice            device,
				     VdpChromaType        surface_chroma_type,
				     VdpYCbCrFormat       bits_ycbcr_format,
				     VdpBool             *is_supported)
{
    if (driver_data == NULL)
	return VDP_STATUS_INVALID_POINTER;
    if (driver_data->vdp_vtable.vdp_video_surface_query_ycbcr_caps == NULL)
	return VDP_STATUS_INVALID_POINTER;
    return driver_data->vdp_vtable.vdp_video_surface_query_ycbcr_caps(device,
								      surface_chroma_type,
								      bits_ycbcr_format,
								      is_supported);
}

// VdpOutputSurfaceQueryGetPutBitsNativeCapabilities
static inline VdpStatus
vdpau_output_surface_query_rgba_caps(vdpau_driver_data_t *driver_data,
				     VdpDevice            device,
				     VdpRGBAFormat        surface_rgba_format,
				     VdpBool             *is_supported)
{
    if (driver_data == NULL)
	return VDP_STATUS_INVALID_POINTER;
    if (driver_data->vdp_vtable.vdp_output_surface_query_rgba_caps == NULL)
	return VDP_STATUS_INVALID_POINTER;
    return driver_data->vdp_vtable.vdp_output_surface_query_rgba_caps(device,
								      surface_rgba_format,
								      is_supported);
}

// VdpGetApiVersion
static inline VdpStatus
vdpau_get_api_version(vdpau_driver_data_t *driver_data, uint32_t *api_version)
{
    if (driver_data == NULL)
	return VDP_STATUS_INVALID_POINTER;
    if (driver_data->vdp_vtable.vdp_get_api_version == NULL)
	return VDP_STATUS_INVALID_POINTER;
    return driver_data->vdp_vtable.vdp_get_api_version(api_version);
}

// VdpGetInformationString
static inline VdpStatus
vdpau_get_information_string(vdpau_driver_data_t *driver_data,
			     const char         **info_string)
{
    if (driver_data == NULL)
	return VDP_STATUS_INVALID_POINTER;
    if (driver_data->vdp_vtable.vdp_get_information_string == NULL)
	return VDP_STATUS_INVALID_POINTER;
    return driver_data->vdp_vtable.vdp_get_information_string(info_string);
}

// Checks whether the VDPAU implementation supports the specified profile
static inline VdpBool
vdpau_is_supported_profile(vdpau_driver_data_t *driver_data,
			   VdpDecoderProfile    profile)
{
    VdpBool is_supported = VDP_FALSE;
    VdpStatus vdp_status;
    uint32_t max_level, max_references, max_width, max_height;
    vdp_status = vdpau_decoder_query_capabilities(driver_data,
						  driver_data->vdp_device,
						  profile,
						  &is_supported,
						  &max_level,
						  &max_references,
						  &max_width,
						  &max_height);
    return vdp_status == VDP_STATUS_OK && is_supported;
}

// Checks whether the VDPAU implementation supports the specified image format
static inline VdpBool
vdpau_is_supported_image_format(vdpau_driver_data_t *driver_data,
				VdpImageFormatType   type,
				uint32_t             format)
{
    VdpBool is_supported = VDP_FALSE;
    VdpStatus vdp_status;
    switch (type) {
    case VDP_IMAGE_FORMAT_TYPE_YCBCR:
	vdp_status = vdpau_video_surface_query_ycbcr_caps(driver_data,
							  driver_data->vdp_device,
							  VDP_CHROMA_TYPE_420,
							  format,
							  &is_supported);
	break;
    case VDP_IMAGE_FORMAT_TYPE_RGBA:
	vdp_status = vdpau_output_surface_query_rgba_caps(driver_data,
							  driver_data->vdp_device,
							  format,
							  &is_supported);
	break;
    }
    return vdp_status == VDP_STATUS_OK && is_supported;
}

// Returns the maximum dimensions supported by the VDPAU implementation for that profile
static inline VdpBool
vdpau_get_surface_size_max(vdpau_driver_data_t *driver_data,
			   VdpDecoderProfile    profile,
			   uint32_t            *pmax_width,
			   uint32_t            *pmax_height)
{
    VdpBool is_supported = VDP_FALSE;
    VdpStatus vdp_status;
    uint32_t max_level, max_references, max_width, max_height;
    vdp_status = vdpau_decoder_query_capabilities(driver_data,
						  driver_data->vdp_device,
						  profile,
						  &is_supported,
						  &max_level,
						  &max_references,
						  &max_width,
						  &max_height);

    if (pmax_width)
	*pmax_width = 0;
    if (pmax_height)
	*pmax_height = 0;

    if (vdp_status != VDP_STATUS_OK || !is_supported)
	return VDP_FALSE;

    if (pmax_width)
	*pmax_width = max_width;
    if (max_height)
	*pmax_height = max_height;

    return VDP_TRUE;
}

static inline VdpBool
vdpau_is_nvidia(vdpau_driver_data_t *driver_data, int *major, int *minor)
{
    uint32_t nvidia_version = 0;
    if (driver_data->vdp_impl_type == VDP_IMPLEMENTATION_NVIDIA)
	nvidia_version = driver_data->vdp_impl_version;
    if (major)
	*major = nvidia_version >> 16;
    if (minor)
	*minor = nvidia_version & 0xffff;
    return nvidia_version != 0;
}


/* ====================================================================== */
/* === VDPAU data dumpers                                             === */
/* ====================================================================== */

#define TRACE			trace_print
#define INDENT(INC)		trace_indent(INC)

static int g_trace_enabled	= -1;
static int g_trace_is_new_line	= 1;
static int g_trace_indent	= 0;

static int check_vdpau_video_trace_env(void)
{
    const char *vdpau_video_trace_str = getenv("VDPAU_VIDEO_TRACE");
    /* XXX: check actual value */
    return vdpau_video_trace_str != NULL;
}

static inline int trace_enabled(void)
{
    if (g_trace_enabled < 0)
	g_trace_enabled = check_vdpau_video_trace_env();
    return g_trace_enabled;
}

static void trace_print(const char *format, ...)
{
    va_list args;

    if (g_trace_is_new_line) {
	int i;
	printf("%s: ", PACKAGE_NAME);
	for (i = 0; i < g_trace_indent; i++)
	    printf("  ");
    }

    va_start(args, format);
    vfprintf(stdout, format, args);
    va_end(args);

    g_trace_is_new_line = (strchr(format, '\n') != NULL);

    if (g_trace_is_new_line)
	fflush(stdout);
}

static void trace_indent(int inc)
{
    g_trace_indent += inc;
}
#define DUMPx(S, M)		TRACE("." #M " = 0x%08x;\n", S->M)
#define DUMPi(S, M)		TRACE("." #M " = %d;\n", S->M)
#define DUMPm(S, M, I, J)	dump_matrix_NxM_1(#M, (uint8_t *)S->M, I, J, I * J)
#define DUMPm16(S, M, I, J)	dump_matrix_NxM_2(#M, (uint16_t *)S->M, I, J, I * J)

// Dumps matrix[N][M] = N rows x M columns (uint8_t)
static void dump_matrix_NxM_1(const char *label, uint8_t *matrix, int N, int M, int L)
{
    int i, j, n = 0;

    TRACE(".%s = {\n", label);
    INDENT(1);
    for (j = 0; j < N; j++) {
	for (i = 0; i < M; i++, n++) {
	    if (n >= L)
		break;
	    if (i > 0)
		TRACE(", ");
	    TRACE("0x%02x", matrix[n]);
	}
	if (j < (N - 1))
	    TRACE(",");
	TRACE("\n");
	if (n >= L)
	    break;
    }
    INDENT(-1);
    TRACE("}\n");
}

// Dumps matrix[N][M] = N rows x M columns (uint16_t)
static void dump_matrix_NxM_2(const char *label, uint16_t *matrix, int N, int M, int L)
{
    int i, j, n = 0;

    TRACE(".%s = {\n", label);
    INDENT(1);
    for (j = 0; j < N; j++) {
	for (i = 0; i < M; i++, n++) {
	    if (n >= L)
		break;
	    if (i > 0)
		TRACE(", ");
	    TRACE("0x%04x", matrix[n]);
	}
	if (j < (N - 1))
	    TRACE(",");
	TRACE("\n");
	if (n >= L)
	    break;
    }
    INDENT(-1);
    TRACE("}\n");
}

static void dump_VdpPictureInfoMPEG1Or2(VdpPictureInfoMPEG1Or2 *pic_info)
{
    INDENT(1);
    TRACE("VdpPictureInfoMPEG1Or2 = {\n");
    INDENT(1);
    DUMPx(pic_info, forward_reference);
    DUMPx(pic_info, backward_reference);
    DUMPi(pic_info, slice_count);
    DUMPi(pic_info, picture_structure);
    DUMPi(pic_info, picture_coding_type);
    DUMPi(pic_info, intra_dc_precision);
    DUMPi(pic_info, frame_pred_frame_dct);
    DUMPi(pic_info, concealment_motion_vectors);
    DUMPi(pic_info, intra_vlc_format);
    DUMPi(pic_info, alternate_scan);
    DUMPi(pic_info, q_scale_type);
    DUMPi(pic_info, top_field_first);
    DUMPi(pic_info, full_pel_forward_vector);
    DUMPi(pic_info, full_pel_backward_vector);
    TRACE(".f_code = { { %d, %d }, { %d, %d } };\n",
	  pic_info->f_code[0][0], pic_info->f_code[0][1],
	  pic_info->f_code[1][0], pic_info->f_code[1][1]);
    DUMPm(pic_info, intra_quantizer_matrix, 8, 8);
    DUMPm(pic_info, non_intra_quantizer_matrix, 8, 8);
    INDENT(-1);
    TRACE("};\n");
    INDENT(-1);
}

static void dump_VdpReferenceFrameH264(const char *label, VdpReferenceFrameH264 *rf)
{
    TRACE(".%s = {\n", label);
    INDENT(1);
    DUMPx(rf, surface);
    DUMPi(rf, is_long_term);
    DUMPi(rf, top_is_reference);
    DUMPi(rf, bottom_is_reference);
    DUMPi(rf, field_order_cnt[0]);
    DUMPi(rf, field_order_cnt[1]);
    DUMPi(rf, frame_idx);
    INDENT(-1);
    TRACE("}\n");
}

static void dump_VdpPictureInfoH264(VdpPictureInfoH264 *pic_info)
{
    int i;

    INDENT(1);
    TRACE("VdpPictureInfoH264 = {\n");
    INDENT(1);
    DUMPi(pic_info, slice_count);
    DUMPi(pic_info, field_order_cnt[0]);
    DUMPi(pic_info, field_order_cnt[1]);
    DUMPi(pic_info, is_reference);
    DUMPi(pic_info, frame_num);
    DUMPi(pic_info, field_pic_flag);
    DUMPi(pic_info, bottom_field_flag);
    DUMPi(pic_info, num_ref_frames);
    DUMPi(pic_info, mb_adaptive_frame_field_flag);
    DUMPi(pic_info, constrained_intra_pred_flag);
    DUMPi(pic_info, weighted_pred_flag);
    DUMPi(pic_info, weighted_bipred_idc);
    DUMPi(pic_info, frame_mbs_only_flag);
    DUMPi(pic_info, transform_8x8_mode_flag);
    DUMPi(pic_info, chroma_qp_index_offset);
    DUMPi(pic_info, second_chroma_qp_index_offset);
    DUMPi(pic_info, pic_init_qp_minus26);
    DUMPi(pic_info, num_ref_idx_l0_active_minus1);