← Back to branch summary

~ubuntu-branches/ubuntu/lucid/schroedinger/lucid

« back to all changes in this revision

Viewing changes to schroedinger/schrovirtframe.c

  • Committer: Bazaar Package Importer
  • Author(s): Sebastien Bacher
  • Date: 2010-04-14 10:58:46 UTC
  • mfrom: (1.1.9 upstream)
  • Revision ID: james.westby@ubuntu.com-20100414105846-p35xtwwse4bf2xvw
Tags: 1.0.9.is.1.0.8-0ubuntu1
https://launchpad.net/bugs/562735
Upload 1.0.8 for lucid since the new version requires orc which is in 
universe and not ready to be promoted yet (the next version will change
the abi and it's still a new technology) (lp: #562735)

Show diffs side-by-side

added added

removed removed

Lines of Context:
schroedinger/schrovirtframe.c
8
8
#include "schrovirtframe.h"
9
9
#include <schroedinger/schro.h>
10
10
#include <schroedinger/schroutils.h>
 
11
#include <liboil/liboil.h>
 
12
#include <schroedinger/schrooil.h>
11
13
#include <string.h>
12
14
#include <math.h>
13
 
#include <orc/orc.h>
14
 
 
15
 
#include <schroedinger/schroorc.h>
16
15
 
17
16
 
18
17
SchroFrame *
52
51
 
53
52
    frame->regions[0] = malloc (frame->components[0].stride * SCHRO_FRAME_CACHE_SIZE);
54
53
    for(i=0;i<SCHRO_FRAME_CACHE_SIZE;i++){
55
 
      frame->cached_lines[0][i] = 0;
 
54
      frame->cached_lines[0][i] = -1;
56
55
    }
57
56
    frame->is_virtual = TRUE;
58
57
 
113
112
 
114
113
    frame->regions[i] = malloc (comp->stride * SCHRO_FRAME_CACHE_SIZE);
115
114
    for(j=0;j<SCHRO_FRAME_CACHE_SIZE;j++){
116
 
      frame->cached_lines[i][j] = 0;
 
115
      frame->cached_lines[i][j] = -1;
117
116
    }
118
117
  }
119
118
  frame->is_virtual = TRUE;
121
120
  return frame;
122
121
}
123
122
 
124
 
static void
125
 
schro_virt_frame_prep_cache_line (SchroFrame *frame, int component, int i)
126
 
{
127
 
  int j;
128
 
 
129
 
  if (i < frame->cache_offset[component]) {
130
 
    SCHRO_ERROR ("cache failure: %d outside [%d,%d]", i,
131
 
        frame->cache_offset[component],
132
 
        frame->cache_offset[component] + SCHRO_FRAME_CACHE_SIZE - 1);
133
 
 
134
 
    frame->cache_offset[component] = i;
135
 
    for(j=0;j<SCHRO_FRAME_CACHE_SIZE; j++) {
136
 
      frame->cached_lines[component][j] = 0;
137
 
    }
138
 
  }
139
 
 
140
 
  while (i >= frame->cache_offset[component] + SCHRO_FRAME_CACHE_SIZE) {
141
 
    j = frame->cache_offset[component] & (SCHRO_FRAME_CACHE_SIZE - 1);
142
 
    frame->cached_lines[component][j] = 0;
143
 
 
144
 
    frame->cache_offset[component]++;
145
 
  }
146
 
}
147
 
 
148
 
void *
149
 
schro_virt_frame_get_line_unrendered (SchroFrame *frame, int component, int i)
150
 
{
151
 
  SchroFrameData *comp = &frame->components[component];
152
 
  int j;
153
 
 
154
 
  //SCHRO_ASSERT(i >= 0);
155
 
  //SCHRO_ASSERT(i < comp->height);
156
 
 
157
 
  if (!frame->is_virtual) {
158
 
    return SCHRO_FRAME_DATA_GET_LINE(&frame->components[component], i);
159
 
  }
160
 
 
161
 
  schro_virt_frame_prep_cache_line (frame, component, i);
162
 
  j = i & (SCHRO_FRAME_CACHE_SIZE - 1);
163
 
 
164
 
  return SCHRO_OFFSET (frame->regions[component], comp->stride * j);
165
 
}
166
 
 
167
123
void *
168
124
schro_virt_frame_get_line (SchroFrame *frame, int component, int i)
169
125
{
170
126
  SchroFrameData *comp = &frame->components[component];
171
127
  int j;
 
128
  int min;
 
129
  int min_j;
172
130
 
173
131
  //SCHRO_ASSERT(i >= 0);
174
132
  //SCHRO_ASSERT(i < comp->height);
177
135
    return SCHRO_FRAME_DATA_GET_LINE(&frame->components[component], i);
178
136
  }
179
137
 
180
 
  schro_virt_frame_prep_cache_line (frame, component, i);
181
 
  j = i & (SCHRO_FRAME_CACHE_SIZE - 1);
182
 
 
183
 
  if (!frame->cached_lines[component][j]) {
184
 
    schro_virt_frame_render_line (frame,
185
 
        SCHRO_OFFSET (frame->regions[component], comp->stride * j), component, i);
186
 
    frame->cached_lines[component][j] = 1;
187
 
  }
188
 
 
189
 
  return SCHRO_OFFSET (frame->regions[component], comp->stride * j);
190
 
}
191
 
 
192
 
void
193
 
schro_virt_frame_set_line_rendered (SchroFrame *frame, int component, int i)
194
 
{
195
 
  int j;
196
 
 
197
 
  //SCHRO_ASSERT(i >= 0);
198
 
  //SCHRO_ASSERT(i < comp->height);
199
 
  //SCHRO_ASSERT(frame->is_virtual);
200
 
 
201
 
  j = i & (SCHRO_FRAME_CACHE_SIZE - 1);
202
 
  frame->cached_lines[component][j] = 1;
 
138
  for(j=0;j<SCHRO_FRAME_CACHE_SIZE;j++){
 
139
    if (frame->cached_lines[component][j] == i) {
 
140
      return SCHRO_OFFSET(frame->regions[component], comp->stride * j);
 
141
    }
 
142
  }
 
143
 
 
144
  min_j = 0;
 
145
  min = frame->cached_lines[component][0];
 
146
  for(j=1;j<SCHRO_FRAME_CACHE_SIZE;j++){
 
147
    if (frame->cached_lines[component][j] < min) {
 
148
      min = frame->cached_lines[component][j];
 
149
      min_j = j;
 
150
    }
 
151
  }
 
152
  frame->cached_lines[component][min_j] = i;
 
153
 
 
154
  schro_virt_frame_render_line (frame,
 
155
      SCHRO_OFFSET(frame->regions[component], comp->stride * min_j),
 
156
      component, i);
 
157
 
 
158
  return SCHRO_OFFSET(frame->regions[component], comp->stride * min_j);
203
159
}
204
160
 
205
161
void
218
174
  src = schro_virt_frame_get_line (frame, component, i);
219
175
  switch (SCHRO_FRAME_FORMAT_DEPTH(frame->format)) {
220
176
    case SCHRO_FRAME_FORMAT_DEPTH_U8:
 
177
#ifdef HAVE_ORC
221
178
      orc_memcpy (dest, src, frame->components[component].width);
 
179
#else
 
180
      oil_memcpy (dest, src, frame->components[component].width);
 
181
#endif
222
182
      break;
223
183
    case SCHRO_FRAME_FORMAT_DEPTH_S16:
 
184
#ifdef HAVE_ORC
224
185
      orc_memcpy (dest, src, frame->components[component].width * 2);
 
186
#else
 
187
      oil_memcpy (dest, src, frame->components[component].width * 2);
 
188
#endif
225
189
      break;
226
190
    default:
227
191
      SCHRO_ASSERT(0);
612
576
{
613
577
  uint8_t *dest = _dest;
614
578
  uint8_t *src;
 
579
#ifndef HAVE_ORC
 
580
  int j;
 
581
#endif
615
582
 
616
583
  src = schro_virt_frame_get_line (frame->virt_frame1, 0, i);
617
584
 
618
585
  switch (component) {
619
586
    case 0:
 
587
#ifdef HAVE_ORC
620
588
      orc_unpack_yuyv_y (dest, (void *)src, frame->width);
 
589
#else
 
590
      for(j=0;j<frame->width;j++){
 
591
        dest[j] = src[j*2];
 
592
      }
 
593
#endif
621
594
      break;
622
595
    case 1:
 
596
#ifdef HAVE_ORC
623
597
      orc_unpack_yuyv_u (dest, (void *)src, frame->width/2);
 
598
#else
 
599
      for(j=0;j<frame->width/2;j++){
 
600
        dest[j] = src[j*4 + 1];
 
601
      }
 
602
#endif
624
603
      break;
625
604
    case 2:
 
605
#ifdef HAVE_ORC
626
606
      orc_unpack_yuyv_v (dest, (void *)src, frame->width/2);
627
 
      break;
628
 
    default:
629
 
      SCHRO_ASSERT(0);
 
607
#else
 
608
      for(j=0;j<frame->width/2;j++){
 
609
        dest[j] = src[j*4 + 3];
 
610
      }
 
611
#endif
630
612
  }
631
613
}
632
614
 
635
617
{
636
618
  uint8_t *dest = _dest;
637
619
  uint8_t *src;
 
620
#ifndef HAVE_ORC
 
621
  int j;
 
622
#endif
638
623
 
639
624
  src = schro_virt_frame_get_line (frame->virt_frame1, 0, i);
640
625
 
641
626
  switch (component) {
642
627
    case 0:
 
628
#ifdef HAVE_ORC
643
629
      orc_unpack_uyvy_y (dest, (void *)src, frame->width);
 
630
#else
 
631
      for(j=0;j<frame->width;j++){
 
632
        dest[j] = src[j*2 + 1];
 
633
      }
 
634
#endif
644
635
      break;
645
636
    case 1:
 
637
#ifdef HAVE_ORC
646
638
      orc_unpack_uyvy_u (dest, (void *)src, frame->width/2);
 
639
#else
 
640
      for(j=0;j<frame->width/2;j++){
 
641
        dest[j] = src[j*4 + 0];
 
642
      }
 
643
#endif
647
644
      break;
648
645
    case 2:
 
646
#ifdef HAVE_ORC
649
647
      orc_unpack_uyvy_v (dest, (void *)src, frame->width/2);
650
 
      break;
651
 
    default:
652
 
      SCHRO_ASSERT(0);
 
648
#else
 
649
      for(j=0;j<frame->width/2;j++){
 
650
        dest[j] = src[j*4 + 2];
 
651
      }
 
652
#endif
653
653
  }
654
654
}
655
655
 
677
677
      for(j=0;j<frame->width;j++){
678
678
        dest[j] = src[j*4 + 3];
679
679
      }
680
 
      break;
681
 
    default:
682
 
      SCHRO_ASSERT(0);
683
680
  }
684
681
}
685
682
 
755
752
        dest[j*3 + 2] = ((READ_UINT32_LE (src + j*16 + 12) >> 10)&0x3ff) >> 2;
756
753
      }
757
754
      break;
758
 
    default:
759
 
      SCHRO_ASSERT(0);
760
755
  }
761
756
}
762
757
 
784
779
      for(j=0;j<frame->width/2;j++){
785
780
        dest[j] = src[j*8 + 4 + 1];
786
781
      }
787
 
      break;
788
 
    default:
789
 
      SCHRO_ASSERT(0);
790
782
  }
791
783
}
792
784
 
842
834
  src_u = schro_virt_frame_get_line (frame->virt_frame1, 1, i);
843
835
  src_v = schro_virt_frame_get_line (frame->virt_frame1, 2, i);
844
836
 
 
837
#ifdef HAVE_ORC
845
838
  orc_packyuyv (dest, src_y, src_u, src_v, frame->width/2);
 
839
#else
 
840
  oil_packyuyv (dest, src_y, src_u, src_v, frame->width/2);
 
841
#endif
846
842
}
847
843
 
848
844
 
1263
1259
  src = schro_virt_frame_get_line (frame->virt_frame1, component, i);
1264
1260
 
1265
1261
  if (component == 0) {
 
1262
#ifdef HAVE_ORC
1266
1263
    orc_memcpy (dest, src, frame->width);
 
1264
#else
 
1265
    oil_memcpy (dest, src, frame->width);
 
1266
#endif
1267
1267
  } else {
1268
1268
    for(j=0;j<frame->components[component].width;j++){
1269
1269
      dest[j] = src[j*2];
1280
1280
 
1281
1281
  if (component == 0) {
1282
1282
    src = schro_virt_frame_get_line (frame->virt_frame1, component, i);
 
1283
#ifdef HAVE_ORC
1283
1284
    orc_memcpy (dest, src, frame->components[component].width);
 
1285
#else
 
1286
    oil_memcpy (dest, src, frame->components[component].width);
 
1287
#endif
1284
1288
  } else {
1285
1289
    src = schro_virt_frame_get_line (frame->virt_frame1, component, i*2);
1286
1290
    for(j=0;j<frame->components[component].width;j++){
1300
1304
  } else {
1301
1305
    src = schro_virt_frame_get_line (frame->virt_frame1, component, i*2);
1302
1306
  }
 
1307
#ifdef HAVE_ORC
1303
1308
  orc_memcpy (dest, src, frame->components[component].width);
 
1309
#else
 
1310
  oil_memcpy (dest, src, frame->components[component].width);
 
1311
#endif
1304
1312
}
1305
1313
 
1306
1314
/* up */
1315
1323
  src = schro_virt_frame_get_line (frame->virt_frame1, component, i);
1316
1324
 
1317
1325
  if (component == 0) {
 
1326
#ifdef HAVE_ORC
1318
1327
    orc_memcpy (dest, src, frame->width);
 
1328
#else
 
1329
    oil_memcpy (dest, src, frame->width);
 
1330
#endif
1319
1331
  } else {
1320
1332
    for(j=0;j<frame->components[component].width;j++){
1321
1333
      dest[j] = src[j>>1];
1332
1344
 
1333
1345
  if (component == 0) {
1334
1346
    src = schro_virt_frame_get_line (frame->virt_frame1, component, i);
 
1347
#ifdef HAVE_ORC
1335
1348
    orc_memcpy (dest, src, frame->components[component].width);
 
1349
#else
 
1350
    oil_memcpy (dest, src, frame->components[component].width);
 
1351
#endif
1336
1352
  } else {
1337
1353
    src = schro_virt_frame_get_line (frame->virt_frame1, component, i>>1);
1338
1354
    for(j=0;j<frame->components[component].width;j++){
1352
1368
  } else {
1353
1369
    src = schro_virt_frame_get_line (frame->virt_frame1, component, i>>1);
1354
1370
  }
 
1371
#ifdef HAVE_ORC
1355
1372
  orc_memcpy (dest, src, frame->components[component].width);
 
1373
#else
 
1374
  oil_memcpy (dest, src, frame->components[component].width);
 
1375
#endif
1356
1376
}
1357
1377
 
1358
1378
SchroFrame *
1509
1529
{
1510
1530
  uint8_t *dest = _dest;
1511
1531
  int16_t *src;
 
1532
#ifndef HAVE_ORC
 
1533
  int16_t c = 128;
 
1534
#endif
1512
1535
 
1513
1536
  src = schro_virt_frame_get_line (frame->virt_frame1, component, i);
 
1537
#ifdef HAVE_ORC
1514
1538
  orc_offsetconvert_u8_s16 (dest, src, frame->components[component].width);
 
1539
#else
 
1540
  oil_addc_s16 (frame->virt_priv, src, &c,
 
1541
      frame->components[component].width);
 
1542
  oil_convert_u8_s16 (dest, frame->virt_priv,
 
1543
      frame->components[component].width);
 
1544
#endif
1515
1545
}
1516
1546
 
1517
1547
SchroFrame *
1535
1565
{
1536
1566
  int16_t *dest = _dest;
1537
1567
  uint8_t *src;
 
1568
#ifndef HAVE_ORC
 
1569
  int16_t c = -128;
 
1570
#endif
1538
1571
 
1539
1572
  src = schro_virt_frame_get_line (frame->virt_frame1, component, i);
1540
1573
 
 
1574
#ifdef HAVE_ORC
1541
1575
  orc_offsetconvert_s16_u8 (dest, src, frame->components[component].width);
 
1576
#else
 
1577
  oil_convert_s16_u8 (dest, src, frame->components[component].width);
 
1578
  oil_addc_s16 (dest, dest, &c, frame->components[component].width);
 
1579
#endif
1542
1580
}
1543
1581
 
1544
1582
SchroFrame *
1563
1601
  uint8_t *src;
1564
1602
 
1565
1603
  src = schro_virt_frame_get_line (frame->virt_frame1, component, i);
 
1604
#ifdef HAVE_ORC
1566
1605
  orc_memcpy (dest, src, frame->components[component].width);
 
1606
#else
 
1607
  oil_memcpy (dest, src, frame->components[component].width);
 
1608
#endif
1567
1609
}
1568
1610
 
1569
1611
static void
1573
1615
  int16_t *src;
1574
1616
 
1575
1617
  src = schro_virt_frame_get_line (frame->virt_frame1, component, i);
 
1618
#ifdef HAVE_ORC
1576
1619
  orc_memcpy (dest, src, frame->components[component].width * sizeof(int16_t));
 
1620
#else
 
1621
  oil_memcpy (dest, src, frame->components[component].width * sizeof(int16_t));
 
1622
#endif
1577
1623
}
1578
1624
 
1579
1625
SchroFrame *
1612
1658
 
1613
1659
  src = schro_virt_frame_get_line (frame->virt_frame1, component,
1614
1660
      MIN(i,srcframe->components[component].height-1));
 
1661
#ifdef HAVE_ORC
1615
1662
  orc_memcpy (dest, src, srcframe->components[component].width);
1616
1663
  orc_splat_u8_ns (dest + srcframe->components[component].width,
1617
1664
      dest[srcframe->components[component].width - 1],
1618
1665
      frame->components[component].width -
1619
1666
      srcframe->components[component].width);
 
1667
#else
 
1668
  oil_memcpy (dest, src, srcframe->components[component].width);
 
1669
  oil_splat_u8_ns (dest + srcframe->components[component].width,
 
1670
      dest + srcframe->components[component].width - 1,
 
1671
      frame->components[component].width -
 
1672
      srcframe->components[component].width);
 
1673
#endif
1620
1674
}
1621
1675
 
1622
1676
static void
1628
1682
 
1629
1683
  src = schro_virt_frame_get_line (frame->virt_frame1, component,
1630
1684
      MIN(i,srcframe->components[component].height-1));
 
1685
#ifdef HAVE_ORC
1631
1686
  orc_memcpy (dest, src,
1632
1687
      srcframe->components[component].width * sizeof(int16_t));
1633
1688
  orc_splat_s16_ns (dest + srcframe->components[component].width,
1634
1689
      dest[srcframe->components[component].width - 1],
1635
1690
      frame->components[component].width -
1636
1691
      srcframe->components[component].width);
 
1692
#else
 
1693
  oil_memcpy (dest, src,
 
1694
      srcframe->components[component].width * sizeof(int16_t));
 
1695
  oil_splat_s16_ns (dest + srcframe->components[component].width,
 
1696
      dest + srcframe->components[component].width - 1,
 
1697
      frame->components[component].width -
 
1698
      srcframe->components[component].width);
 
1699
#endif
1637
1700
}
1638
1701
 
1639
1702
SchroFrame *