← Back to branch summary

~ubuntu-branches/ubuntu/quantal/mesa/quantal

« back to all changes in this revision

Viewing changes to src/mesa/drivers/dri/unichrome/via_context.c

  • Committer: Bazaar Package Importer
  • Author(s): Sebastien Bacher
  • Date: 2007-02-21 12:44:07 UTC
  • mfrom: (1.2.1 upstream)
  • mto: This revision was merged to the branch mainline in revision 22.
  • Revision ID: james.westby@ubuntu.com-20070221124407-rgcacs32mycrtadl
Import upstream version 6.5.2

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/mesa/drivers/dri/unichrome/via_context.c
147
147
 
148
148
 
149
149
static void
150
 
viaInitRenderbuffer(struct gl_renderbuffer *rb, GLenum format)
 
150
viaInitRenderbuffer(struct via_renderbuffer *vrb, GLenum format,
 
151
                    __DRIdrawablePrivate *dPriv)
151
152
{
152
153
   const GLuint name = 0;
 
154
   struct gl_renderbuffer *rb = & vrb->Base;
153
155
 
 
156
   vrb->dPriv = dPriv;
154
157
   _mesa_init_renderbuffer(rb, name);
155
158
 
156
159
   /* Make sure we're using a null-valued GetPointer routine */
198
201
 * \sa AllocateBuffer
199
202
 */
200
203
static GLboolean
201
 
calculate_buffer_parameters( struct via_context *vmesa,
202
 
                             struct gl_framebuffer *fb )
 
204
calculate_buffer_parameters(struct via_context *vmesa,
 
205
                            struct gl_framebuffer *fb,
 
206
                            __DRIdrawablePrivate *dPriv)
203
207
{
204
208
   const unsigned shift = vmesa->viaScreen->bitsPerPixel / 16;
205
209
   const unsigned extra = 32;
215
219
 
216
220
   if (!vmesa->front.Base.InternalFormat) {
217
221
      /* do one-time init for the renderbuffers */
218
 
      viaInitRenderbuffer(&vmesa->front.Base, GL_RGBA);
 
222
      viaInitRenderbuffer(&vmesa->front, GL_RGBA, dPriv);
219
223
      viaSetSpanFunctions(&vmesa->front, &fb->Visual);
220
224
      _mesa_add_renderbuffer(fb, BUFFER_FRONT_LEFT, &vmesa->front.Base);
221
225
 
222
226
      if (fb->Visual.doubleBufferMode) {
223
 
         viaInitRenderbuffer(&vmesa->back.Base, GL_RGBA);
 
227
         viaInitRenderbuffer(&vmesa->back, GL_RGBA, dPriv);
224
228
         viaSetSpanFunctions(&vmesa->back, &fb->Visual);
225
229
         _mesa_add_renderbuffer(fb, BUFFER_BACK_LEFT, &vmesa->back.Base);
226
230
      }
227
231
 
228
232
      if (vmesa->glCtx->Visual.depthBits > 0) {
229
 
         viaInitRenderbuffer(&vmesa->depth.Base, 
 
233
         viaInitRenderbuffer(&vmesa->depth,
230
234
                             (vmesa->glCtx->Visual.depthBits == 16
231
 
                              ? GL_DEPTH_COMPONENT16 : GL_DEPTH_COMPONENT24));
 
235
                              ? GL_DEPTH_COMPONENT16 : GL_DEPTH_COMPONENT24),
 
236
                             dPriv);
232
237
         viaSetSpanFunctions(&vmesa->depth, &fb->Visual);
233
238
         _mesa_add_renderbuffer(fb, BUFFER_DEPTH, &vmesa->depth.Base);
234
239
      }
235
240
 
236
241
      if (vmesa->glCtx->Visual.stencilBits > 0) {
237
 
         viaInitRenderbuffer(&vmesa->stencil.Base, GL_STENCIL_INDEX8_EXT);
 
242
         viaInitRenderbuffer(&vmesa->stencil, GL_STENCIL_INDEX8_EXT,
 
243
                             dPriv);
238
244
         viaSetSpanFunctions(&vmesa->stencil, &fb->Visual);
239
245
         _mesa_add_renderbuffer(fb, BUFFER_STENCIL, &vmesa->stencil.Base);
240
246
      }
243
249
   assert(vmesa->front.Base.InternalFormat);
244
250
   assert(vmesa->front.Base.AllocStorage);
245
251
   if (fb->Visual.doubleBufferMode) {
246
 
      assert(fb->Attachment[BUFFER_BACK_LEFT].Renderbuffer);
247
 
      assert(vmesa->front.Base.AllocStorage);
 
252
      assert(vmesa->back.Base.AllocStorage);
248
253
   }
249
254
   if (fb->Visual.depthBits) {
250
 
      assert(fb->Attachment[BUFFER_DEPTH].Renderbuffer);
251
255
      assert(vmesa->depth.Base.AllocStorage);
252
256
   }
253
257
 
352
356
{
353
357
    struct via_context *vmesa = VIA_CONTEXT(ctx);
354
358
 
355
 
    calculate_buffer_parameters( vmesa, drawbuffer );
 
359
    calculate_buffer_parameters(vmesa, drawbuffer, vmesa->driDrawable);
356
360
 
357
361
    _mesa_resize_framebuffer(ctx, drawbuffer, width, height);
358
362
}
359
363
 
360
 
static void viaBufferSize(GLframebuffer *buffer, GLuint *width, GLuint *height)
361
 
{
362
 
    GET_CURRENT_CONTEXT(ctx);
363
 
    struct via_context *vmesa = VIA_CONTEXT(ctx);       
364
 
    *width = vmesa->driDrawable->w;
365
 
    *height = vmesa->driDrawable->h;
366
 
}
367
 
 
368
364
/* Extension strings exported by the Unichrome driver.
369
365
 */
370
366
const struct dri_extension card_extensions[] =
481
477
    /* Parse configuration files.
482
478
     */
483
479
    driParseConfigFiles (&vmesa->optionCache, &viaScreen->optionCache,
484
 
                         sPriv->myNum, "via");
 
480
                         sPriv->myNum, "unichrome");
485
481
 
486
482
    /* pick back buffer */
487
483
    vmesa->hasBack = visual->doubleBufferMode;
557
553
    driContextPriv->driverPrivate = vmesa;
558
554
 
559
555
    ctx = vmesa->glCtx;
560
 
    
561
 
    ctx->Const.MaxTextureLevels = 10;    
 
556
 
 
557
    if (driQueryOptionb(&vmesa->optionCache, "excess_mipmap"))
 
558
        ctx->Const.MaxTextureLevels = 11;
 
559
    else
 
560
        ctx->Const.MaxTextureLevels = 10;
 
561
 
562
562
    ctx->Const.MaxTextureUnits = 2;
563
563
    ctx->Const.MaxTextureImageUnits = ctx->Const.MaxTextureUnits;
564
564
    ctx->Const.MaxTextureCoordUnits = ctx->Const.MaxTextureUnits;
575
575
    ctx->Const.MaxPointSizeAA = 1.0;
576
576
    ctx->Const.PointSizeGranularity = 1.0;
577
577
 
578
 
    ctx->Driver.GetBufferSize = viaBufferSize;
579
 
/*    ctx->Driver.ResizeBuffers = _swrast_alloc_buffers;  *//* FIXME ?? */
580
578
    ctx->Driver.GetString = viaGetString;
581
579
 
582
580
    ctx->DriverCtx = (void *)vmesa;
657
655
       VIA_DEBUG = driParseDebugString( getenv( "VIA_DEBUG" ),
658
656
                                        debug_control );
659
657
 
660
 
    if (getenv("VIA_NO_RAST"))
 
658
    if (getenv("VIA_NO_RAST") ||
 
659
        driQueryOptionb(&vmesa->optionCache, "no_rast"))
661
660
       FALLBACK(vmesa, VIA_FALLBACK_USER_DISABLE, 1);
662
661
 
663
 
    /* I don't understand why this isn't working:
664
 
     */
665
662
    vmesa->vblank_flags =
666
663
       vmesa->viaScreen->irqEnabled ?
667
664
        driGetDefaultVBlankFlags(&vmesa->optionCache) : VBLANK_FLAG_NO_IRQ;
668
665
 
669
 
    /* Hack this up in its place:
670
 
     */
671
 
    vmesa->vblank_flags = (getenv("VIA_VSYNC") ? 
672
 
                           VBLANK_FLAG_SYNC : VBLANK_FLAG_NO_IRQ);
673
 
 
674
666
    if (getenv("VIA_PAGEFLIP"))
675
667
       vmesa->allowPageFlip = 1;
676
668
 
728
720
        assert (is_empty_list(&vmesa->tex_image_list[VIA_MEM_SYSTEM]));
729
721
        assert (is_empty_list(&vmesa->freed_tex_buffers));
730
722
 
731
 
        FREE(vmesa);
 
723
        driDestroyOptionCache(&vmesa->optionCache);
 
724
 
 
725
        FREE(vmesa);
732
726
    }
733
727
}
734
728
 
735
729
 
736
730
void viaXMesaWindowMoved(struct via_context *vmesa)
737
731
{
738
 
   __DRIdrawablePrivate *dPriv = vmesa->driDrawable;
 
732
   __DRIdrawablePrivate *const drawable = vmesa->driDrawable;
 
733
   __DRIdrawablePrivate *const readable = vmesa->driReadable;
 
734
   struct via_renderbuffer *const draw_buffer = 
 
735
     (struct via_renderbuffer *) drawable->driverPrivate;
 
736
   struct via_renderbuffer *const read_buffer =
 
737
     (struct via_renderbuffer *) readable->driverPrivate;
739
738
   GLuint bytePerPixel = vmesa->viaScreen->bitsPerPixel >> 3;
740
739
 
741
 
   if (!dPriv)
 
740
   if (!drawable)
742
741
      return;
743
742
   
744
743
   switch (vmesa->glCtx->DrawBuffer->_ColorDrawBufferMask[0]) {
745
744
   case BUFFER_BIT_BACK_LEFT: 
746
 
      if (dPriv->numBackClipRects == 0) {
747
 
         vmesa->numClipRects = dPriv->numClipRects;
748
 
         vmesa->pClipRects = dPriv->pClipRects;
 
745
      if (drawable->numBackClipRects == 0) {
 
746
         vmesa->numClipRects = drawable->numClipRects;
 
747
         vmesa->pClipRects = drawable->pClipRects;
749
748
      } 
750
749
      else {
751
 
         vmesa->numClipRects = dPriv->numBackClipRects;
752
 
         vmesa->pClipRects = dPriv->pBackClipRects;
 
750
         vmesa->numClipRects = drawable->numBackClipRects;
 
751
         vmesa->pClipRects = drawable->pBackClipRects;
753
752
      }
754
753
      break;
755
754
   case BUFFER_BIT_FRONT_LEFT:
756
 
      vmesa->numClipRects = dPriv->numClipRects;
757
 
      vmesa->pClipRects = dPriv->pClipRects;
 
755
      vmesa->numClipRects = drawable->numClipRects;
 
756
      vmesa->pClipRects = drawable->pClipRects;
758
757
      break;
759
758
   default:
760
759
      vmesa->numClipRects = 0;
761
760
      break;
762
761
   }
763
762
 
764
 
   if (vmesa->drawW != dPriv->w ||
765
 
       vmesa->drawH != dPriv->h) 
766
 
      calculate_buffer_parameters( vmesa, vmesa->glCtx->DrawBuffer );
 
763
   if ((draw_buffer->drawW != drawable->w) 
 
764
       || (draw_buffer->drawH != drawable->h)) {
 
765
      calculate_buffer_parameters(vmesa, vmesa->glCtx->DrawBuffer,
 
766
                                  drawable);
 
767
   }
767
768
 
768
 
   vmesa->drawXoff = (GLuint)(((dPriv->x * bytePerPixel) & 0x1f) / 
 
769
   draw_buffer->drawXoff = (GLuint)(((drawable->x * bytePerPixel) & 0x1f) / 
769
770
                              bytePerPixel);  
770
 
   vmesa->drawX = dPriv->x - vmesa->drawXoff;
771
 
   vmesa->drawY = dPriv->y;
772
 
   vmesa->drawW = dPriv->w;
773
 
   vmesa->drawH = dPriv->h;
 
771
   draw_buffer->drawX = drawable->x - draw_buffer->drawXoff;
 
772
   draw_buffer->drawY = drawable->y;
 
773
   draw_buffer->drawW = drawable->w;
 
774
   draw_buffer->drawH = drawable->h;
 
775
 
 
776
   if (drawable != readable) {
 
777
      if ((read_buffer->drawW != readable->w) 
 
778
          || (read_buffer->drawH != readable->h)) {
 
779
         calculate_buffer_parameters(vmesa, vmesa->glCtx->ReadBuffer,
 
780
                                     readable);
 
781
      }
 
782
 
 
783
      read_buffer->drawXoff = (GLuint)(((readable->x * bytePerPixel) & 0x1f) / 
 
784
                                       bytePerPixel);  
 
785
      read_buffer->drawX = readable->x - read_buffer->drawXoff;
 
786
      read_buffer->drawY = readable->y;
 
787
      read_buffer->drawW = readable->w;
 
788
      read_buffer->drawH = readable->h;
 
789
   }
774
790
 
775
791
   vmesa->front.orig = (vmesa->front.offset + 
776
 
                        vmesa->drawY * vmesa->front.pitch + 
777
 
                        vmesa->drawX * bytePerPixel);
 
792
                        draw_buffer->drawY * vmesa->front.pitch + 
 
793
                        draw_buffer->drawX * bytePerPixel);
778
794
 
779
795
   vmesa->front.origMap = (vmesa->front.map + 
780
 
                           vmesa->drawY * vmesa->front.pitch + 
781
 
                           vmesa->drawX * bytePerPixel);
 
796
                           draw_buffer->drawY * vmesa->front.pitch + 
 
797
                           draw_buffer->drawX * bytePerPixel);
782
798
 
783
799
   vmesa->back.orig = vmesa->back.offset;
784
800
   vmesa->depth.orig = vmesa->depth.offset;   
814
830
        drawBuffer = (GLframebuffer *)driDrawPriv->driverPrivate;
815
831
        readBuffer = (GLframebuffer *)driReadPriv->driverPrivate;
816
832
 
817
 
        if ( vmesa->driDrawable != driDrawPriv ) {
818
 
           driDrawableInitVBlank( driDrawPriv, vmesa->vblank_flags );
819
 
           vmesa->driDrawable = driDrawPriv;
820
 
           if ( ! calculate_buffer_parameters( vmesa, drawBuffer ) ) {
821
 
              return GL_FALSE;
822
 
           }
 
833
        if (vmesa->driDrawable != driDrawPriv) {
 
834
           driDrawableInitVBlank(driDrawPriv, vmesa->vblank_flags,
 
835
                                 &vmesa->vbl_seq);
823
836
        }
824
837
 
 
838
       if ((vmesa->driDrawable != driDrawPriv)
 
839
           || (vmesa->driReadable != driReadPriv)) {
 
840
          vmesa->driDrawable = driDrawPriv;
 
841
          vmesa->driReadable = driReadPriv;
 
842
 
 
843
          if ((drawBuffer->Width != driDrawPriv->w) 
 
844
              || (drawBuffer->Height != driDrawPriv->h)) {
 
845
             _mesa_resize_framebuffer(ctx, drawBuffer,
 
846
                                      driDrawPriv->w, driDrawPriv->h);
 
847
             drawBuffer->Initialized = GL_TRUE;
 
848
          }
 
849
 
 
850
          if (!calculate_buffer_parameters(vmesa, drawBuffer, driDrawPriv)) {
 
851
             return GL_FALSE;
 
852
          }
 
853
 
 
854
          if (driDrawPriv != driReadPriv) {
 
855
             if ((readBuffer->Width != driReadPriv->w)
 
856
                 || (readBuffer->Height != driReadPriv->h)) {
 
857
                _mesa_resize_framebuffer(ctx, readBuffer,
 
858
                                         driReadPriv->w, driReadPriv->h);
 
859
                readBuffer->Initialized = GL_TRUE;
 
860
             }
 
861
 
 
862
             if (!calculate_buffer_parameters(vmesa, readBuffer, driReadPriv)) {
 
863
                return GL_FALSE;
 
864
             }
 
865
          }
 
866
       }
 
867
 
825
868
        _mesa_make_current(vmesa->glCtx, drawBuffer, readBuffer);
826
869
 
827
870
        ctx->Driver.DrawBuffer( ctx, ctx->Color.DrawBuffer[0] );
847
890
 
848
891
    drmGetLock(vmesa->driFd, vmesa->hHWContext, flags);
849
892
 
850
 
    DRI_VALIDATE_DRAWABLE_INFO( sPriv, dPriv );
 
893
    DRI_VALIDATE_DRAWABLE_INFO(sPriv, dPriv);
 
894
    if (dPriv != vmesa->driReadable) {
 
895
        DRI_VALIDATE_DRAWABLE_INFO(sPriv, vmesa->driReadable);
 
896
    }
851
897
 
852
898
    if (vmesa->sarea->ctxOwner != vmesa->hHWContext) {
853
899
       vmesa->sarea->ctxOwner = vmesa->hHWContext;