st/vdpau: use template size as default for source_rect.

[mesa.git] / src / gallium / state_trackers / vdpau / mixer.c

diff --git a/src/gallium/state_trackers/vdpau/mixer.c b/src/gallium/state_trackers/vdpau/mixer.c
index 9a97501e456cf3bd9a1070d435f5b714192b338e..81a5c2936853309aa4f1bbaf7c45ade5f9459c59 100644 (file)
--- a/src/gallium/state_trackers/vdpau/mixer.c
+++ b/src/gallium/state_trackers/vdpau/mixer.c
@@ -62,11 +62,14 @@ vlVdpVideoMixerCreate(VdpDevice device,
       return VDP_STATUS_RESOURCES;
 
    vmixer->device = dev;
+
+   pipe_mutex_lock(dev->mutex);
+
    vl_compositor_init_state(&vmixer->cstate, dev->context);
 
-   vl_csc_get_matrix(VL_CSC_COLOR_STANDARD_BT_601, NULL, true, vmixer->csc);
+   vl_csc_get_matrix(VL_CSC_COLOR_STANDARD_BT_601, NULL, true, &vmixer->csc);
    if (!debug_get_bool_option("G3DVL_NO_CSC", FALSE))
-      vl_compositor_set_csc_matrix(&vmixer->cstate, vmixer->csc);
+      vl_compositor_set_csc_matrix(&vmixer->cstate, (const vl_csc_matrix *)&vmixer->csc);
 
    *mixer = vlAddDataHTAB(vmixer);
    if (*mixer == 0) {
@@ -143,6 +146,7 @@ vlVdpVideoMixerCreate(VdpDevice device,
    }
    vmixer->luma_key_min = 0.f;
    vmixer->luma_key_max = 1.f;
+   pipe_mutex_unlock(dev->mutex);
 
    return VDP_STATUS_OK;
 
@@ -151,6 +155,7 @@ no_params:
 
 no_handle:
    vl_compositor_cleanup_state(&vmixer->cstate);
+   pipe_mutex_unlock(dev->mutex);
    FREE(vmixer);
    return ret;
 }
@@ -166,6 +171,11 @@ vlVdpVideoMixerDestroy(VdpVideoMixer mixer)
    vmixer = vlGetDataHTAB(mixer);
    if (!vmixer)
       return VDP_STATUS_INVALID_HANDLE;
+
+   pipe_mutex_lock(vmixer->device->mutex);
+
+   vlVdpResolveDelayedRendering(vmixer->device, NULL, NULL);
+
    vlRemoveDataHTAB(mixer);
 
    vl_compositor_cleanup_state(&vmixer->cstate);
@@ -179,6 +189,7 @@ vlVdpVideoMixerDestroy(VdpVideoMixer mixer)
       vl_matrix_filter_cleanup(vmixer->sharpness.filter);
       FREE(vmixer->sharpness.filter);
    }
+   pipe_mutex_unlock(vmixer->device->mutex);
 
    FREE(vmixer);
 
@@ -204,9 +215,9 @@ VdpStatus vlVdpVideoMixerRender(VdpVideoMixer mixer,
                                 uint32_t layer_count,
                                 VdpLayer const *layers)
 {
-   struct u_rect src_rect, dst_rect, dst_clip;
    enum vl_compositor_deinterlace deinterlace;
-   unsigned layer = 0;
+   struct u_rect rect, clip, *prect;
+   unsigned i, layer = 0;
 
    vlVdpVideoMixer *vmixer;
    vlVdpSurface *surf;
@@ -239,12 +250,16 @@ VdpStatus vlVdpVideoMixerRender(VdpVideoMixer mixer,
    if (!dst)
       return VDP_STATUS_INVALID_HANDLE;
 
+   pipe_mutex_lock(vmixer->device->mutex);
+   vlVdpResolveDelayedRendering(vmixer->device, NULL, NULL);
    if (background_surface != VDP_INVALID_HANDLE) {
       vlVdpOutputSurface *bg = vlGetDataHTAB(background_surface);
-      if (!bg)
+      if (!bg) {
+         pipe_mutex_unlock(vmixer->device->mutex);
          return VDP_STATUS_INVALID_HANDLE;
+      }
       vl_compositor_set_rgba_layer(&vmixer->cstate, compositor, layer++, bg->sampler_view,
-                                   RectToPipe(background_source_rect, &src_rect), NULL, NULL);
+                                   RectToPipe(background_source_rect, &rect), NULL, NULL);
    }
 
    vl_compositor_clear_layers(&vmixer->cstate);
@@ -263,24 +278,54 @@ VdpStatus vlVdpVideoMixerRender(VdpVideoMixer mixer,
       break;
 
    default:
+      pipe_mutex_unlock(vmixer->device->mutex);
       return VDP_STATUS_INVALID_VIDEO_MIXER_PICTURE_STRUCTURE;
    };
-   vl_compositor_set_buffer_layer(&vmixer->cstate, compositor, layer, surf->video_buffer,
-                                  RectToPipe(video_source_rect, &src_rect), NULL, deinterlace);
-   vl_compositor_set_layer_dst_area(&vmixer->cstate, layer++, RectToPipe(destination_video_rect, &dst_rect));
-   vl_compositor_set_dst_clip(&vmixer->cstate, RectToPipe(destination_rect, &dst_clip));
-   vl_compositor_render(&vmixer->cstate, compositor, dst->surface, &dst->dirty_area);
-
-   /* applying the noise reduction after scaling is actually not very
-      clever, but currently we should avoid to copy around the image
-      data once more. */
-   if (vmixer->noise_reduction.filter)
-      vl_median_filter_render(vmixer->noise_reduction.filter,
-                              dst->sampler_view, dst->surface);
-
-   if (vmixer->sharpness.filter)
-      vl_matrix_filter_render(vmixer->sharpness.filter,
-                              dst->sampler_view, dst->surface);
+   prect = RectToPipe(video_source_rect, &rect);
+   if (!prect) {
+      rect.x0 = 0;
+      rect.y0 = 0;
+      rect.x1 = surf->templat.width;
+      rect.y1 = surf->templat.height;
+      prect = ▭
+   }
+   vl_compositor_set_buffer_layer(&vmixer->cstate, compositor, layer, surf->video_buffer, prect, NULL, deinterlace);
+   vl_compositor_set_layer_dst_area(&vmixer->cstate, layer++, RectToPipe(destination_video_rect, &rect));
+
+   for (i = 0; i < layer_count; ++i) {
+      vlVdpOutputSurface *src = vlGetDataHTAB(layers->source_surface);
+      if (!src) {
+         pipe_mutex_unlock(vmixer->device->mutex);
+         return VDP_STATUS_INVALID_HANDLE;
+      }
+
+      assert(layers->struct_version == VDP_LAYER_VERSION);
+
+      vl_compositor_set_rgba_layer(&vmixer->cstate, compositor, layer, src->sampler_view,
+                                   RectToPipe(layers->source_rect, &rect), NULL, NULL);
+      vl_compositor_set_layer_dst_area(&vmixer->cstate, layer++, RectToPipe(layers->destination_rect, &rect));
+
+      ++layers;
+   }
+
+   vl_compositor_set_dst_clip(&vmixer->cstate, RectToPipe(destination_rect, &clip));
+   if (!vmixer->noise_reduction.filter && !vmixer->sharpness.filter)
+      vlVdpSave4DelayedRendering(vmixer->device, destination_surface, &vmixer->cstate);
+   else {
+      vl_compositor_render(&vmixer->cstate, compositor, dst->surface, &dst->dirty_area);
+
+      /* applying the noise reduction after scaling is actually not very
+         clever, but currently we should avoid to copy around the image
+         data once more. */
+      if (vmixer->noise_reduction.filter)
+         vl_median_filter_render(vmixer->noise_reduction.filter,
+                                 dst->sampler_view, dst->surface);
+
+      if (vmixer->sharpness.filter)
+         vl_matrix_filter_render(vmixer->sharpness.filter,
+                                 dst->sampler_view, dst->surface);
+   }
+   pipe_mutex_unlock(vmixer->device->mutex);
 
    return VDP_STATUS_OK;
 }
@@ -428,6 +473,7 @@ vlVdpVideoMixerSetFeatureEnables(VdpVideoMixer mixer,
    if (!vmixer)
       return VDP_STATUS_INVALID_HANDLE;
 
+   pipe_mutex_lock(vmixer->device->mutex);
    for (i = 0; i < feature_count; ++i) {
       switch (features[i]) {
       /* they are valid, but we doesn't support them */
@@ -457,9 +503,11 @@ vlVdpVideoMixerSetFeatureEnables(VdpVideoMixer mixer,
          break;
 
       default:
+         pipe_mutex_unlock(vmixer->device->mutex);
          return VDP_STATUS_INVALID_VIDEO_MIXER_FEATURE;
       }
    }
+   pipe_mutex_unlock(vmixer->device->mutex);
 
    return VDP_STATUS_OK;
 }
@@ -539,6 +587,7 @@ vlVdpVideoMixerSetAttributeValues(VdpVideoMixer mixer,
    if (!vmixer)
       return VDP_STATUS_INVALID_HANDLE;
 
+   pipe_mutex_lock(vmixer->device->mutex);
    for (i = 0; i < attribute_count; ++i) {
       switch (attributes[i]) {
       case VDP_VIDEO_MIXER_ATTRIBUTE_BACKGROUND_COLOR:
@@ -553,11 +602,11 @@ vlVdpVideoMixerSetAttributeValues(VdpVideoMixer mixer,
          vdp_csc = attribute_values[i];
          vmixer->custom_csc = !!vdp_csc;
          if (!vdp_csc)
-            vl_csc_get_matrix(VL_CSC_COLOR_STANDARD_BT_601, NULL, 1, vmixer->csc);
+            vl_csc_get_matrix(VL_CSC_COLOR_STANDARD_BT_601, NULL, 1, &vmixer->csc);
          else
-            memcpy(vmixer->csc, vdp_csc, sizeof(float)*12);
+            memcpy(vmixer->csc, vdp_csc, sizeof(vl_csc_matrix));
          if (!debug_get_bool_option("G3DVL_NO_CSC", FALSE))
-            vl_compositor_set_csc_matrix(&vmixer->cstate, vmixer->csc);
+            vl_compositor_set_csc_matrix(&vmixer->cstate, (const vl_csc_matrix *)&vmixer->csc);
          break;
 
       case VDP_VIDEO_MIXER_ATTRIBUTE_NOISE_REDUCTION_LEVEL:
@@ -599,9 +648,11 @@ vlVdpVideoMixerSetAttributeValues(VdpVideoMixer mixer,
          vmixer->skip_chroma_deint = *(uint8_t*)attribute_values[i];
          break;
       default:
+         pipe_mutex_unlock(vmixer->device->mutex);
          return VDP_STATUS_INVALID_VIDEO_MIXER_ATTRIBUTE;
       }
    }
+   pipe_mutex_unlock(vmixer->device->mutex);
 
    return VDP_STATUS_OK;
 }
@@ -664,6 +715,7 @@ vlVdpVideoMixerGetAttributeValues(VdpVideoMixer mixer,
    if (!vmixer)
       return VDP_STATUS_INVALID_HANDLE;
 
+   pipe_mutex_lock(vmixer->device->mutex);
    for (i = 0; i < attribute_count; ++i) {
       switch (attributes[i]) {
       case VDP_VIDEO_MIXER_ATTRIBUTE_BACKGROUND_COLOR:
@@ -695,9 +747,11 @@ vlVdpVideoMixerGetAttributeValues(VdpVideoMixer mixer,
          *(uint8_t*)attribute_values[i] = vmixer->skip_chroma_deint;
          break;
       default:
+         pipe_mutex_unlock(vmixer->device->mutex);
          return VDP_STATUS_INVALID_VIDEO_MIXER_ATTRIBUTE;
       }
    }
+   pipe_mutex_unlock(vmixer->device->mutex);
    return VDP_STATUS_OK;
 }
 
@@ -709,7 +763,6 @@ vlVdpGenerateCSCMatrix(VdpProcamp *procamp,
                        VdpColorStandard standard,
                        VdpCSCMatrix *csc_matrix)
 {
-   float matrix[16];
    enum VL_CSC_COLOR_STANDARD vl_std;
    struct vl_procamp camp;
 
@@ -729,7 +782,6 @@ vlVdpGenerateCSCMatrix(VdpProcamp *procamp,
    camp.contrast = procamp->contrast;
    camp.saturation = procamp->saturation;
    camp.hue = procamp->hue;
-   vl_csc_get_matrix(vl_std, &camp, 1, matrix);
-   memcpy(csc_matrix, matrix, sizeof(float)*12);
+   vl_csc_get_matrix(vl_std, &camp, true, csc_matrix);
    return VDP_STATUS_OK;
 }