← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/libav/oneiric

« back to all changes in this revision

Viewing changes to libavcodec/vc1dsp.c

  • Committer: Bazaar Package Importer
  • Author(s): Reinhard Tartler
  • Date: 2011-04-30 14:27:42 UTC
  • mfrom: (1.1.2 experimental)
  • Revision ID: james.westby@ubuntu.com-20110430142742-quvblxk1tj6adlh5
Tags: 4:0.7~b1-1ubuntu1
http://bugs.debian.org/623682
* Merge from debian. Remaining changes:
  - don't build against libfaad, libdirac, librtmp and libopenjpeg
    (all in universe)
  - explicitly --enable-pic on powerpc, cf. LP #654666
  - different arm configure bits that should probably better be
    merged into debian
* Cherry-picked from git: 
  - install doc/APIChanges and refer to them in NEWS.Debian (Closes: #623682)
  - don't try to install non-existing documentation, fixes FTBFS on powerpc

Show diffs side-by-side

added added

removed removed

Lines of Context:
libavcodec/vc1dsp.c
2
2
 * VC-1 and WMV3 decoder - DSP functions
3
3
 * Copyright (c) 2006 Konstantin Shishkov
4
4
 *
5
 
 * This file is part of FFmpeg.
 
5
 * This file is part of Libav.
6
6
 *
7
 
 * FFmpeg is free software; you can redistribute it and/or
 
7
 * Libav is free software; you can redistribute it and/or
8
8
 * modify it under the terms of the GNU Lesser General Public
9
9
 * License as published by the Free Software Foundation; either
10
10
 * version 2.1 of the License, or (at your option) any later version.
11
11
 *
12
 
 * FFmpeg is distributed in the hope that it will be useful,
 
12
 * Libav is distributed in the hope that it will be useful,
13
13
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14
14
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15
15
 * Lesser General Public License for more details.
16
16
 *
17
17
 * You should have received a copy of the GNU Lesser General Public
18
 
 * License along with FFmpeg; if not, write to the Free Software
 
18
 * License along with Libav; if not, write to the Free Software
19
19
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20
20
 */
21
21
 
25
25
 *
26
26
 */
27
27
 
28
 
#include "dsputil.h"
 
28
#include "vc1dsp.h"
29
29
 
30
30
 
31
31
/** Apply overlap transform to horizontal edge
182
182
{
183
183
    int i;
184
184
    int dc = block[0];
185
 
    const uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
 
185
    const uint8_t *cm;
186
186
    dc = (3 * dc +  1) >> 1;
187
187
    dc = (3 * dc + 16) >> 5;
 
188
    cm = ff_cropTbl + MAX_NEG_CROP + dc;
188
189
    for(i = 0; i < 8; i++){
189
 
        dest[0] = cm[dest[0]+dc];
190
 
        dest[1] = cm[dest[1]+dc];
191
 
        dest[2] = cm[dest[2]+dc];
192
 
        dest[3] = cm[dest[3]+dc];
193
 
        dest[4] = cm[dest[4]+dc];
194
 
        dest[5] = cm[dest[5]+dc];
195
 
        dest[6] = cm[dest[6]+dc];
196
 
        dest[7] = cm[dest[7]+dc];
 
190
        dest[0] = cm[dest[0]];
 
191
        dest[1] = cm[dest[1]];
 
192
        dest[2] = cm[dest[2]];
 
193
        dest[3] = cm[dest[3]];
 
194
        dest[4] = cm[dest[4]];
 
195
        dest[5] = cm[dest[5]];
 
196
        dest[6] = cm[dest[6]];
 
197
        dest[7] = cm[dest[7]];
197
198
        dest += linesize;
198
199
    }
199
200
}
200
201
 
201
 
static void vc1_inv_trans_8x8_c(DCTELEM block[64])
 
202
static av_always_inline void vc1_inv_trans_8x8_c(DCTELEM block[64], int shl, int sub)
202
203
{
203
204
    int i;
204
205
    register int t1,t2,t3,t4,t5,t6,t7,t8;
205
 
    DCTELEM *src, *dst;
 
206
    DCTELEM *src, *dst, temp[64];
206
207
 
207
208
    src = block;
208
 
    dst = block;
 
209
    dst = temp;
209
210
    for(i = 0; i < 8; i++){
210
 
        t1 = 12 * (src[0] + src[4]) + 4;
211
 
        t2 = 12 * (src[0] - src[4]) + 4;
212
 
        t3 = 16 * src[2] +  6 * src[6];
213
 
        t4 =  6 * src[2] - 16 * src[6];
 
211
        t1 = 12 * (src[ 0] + src[32]) + 4;
 
212
        t2 = 12 * (src[ 0] - src[32]) + 4;
 
213
        t3 = 16 * src[16] +  6 * src[48];
 
214
        t4 =  6 * src[16] - 16 * src[48];
214
215
 
215
216
        t5 = t1 + t3;
216
217
        t6 = t2 + t4;
217
218
        t7 = t2 - t4;
218
219
        t8 = t1 - t3;
219
220
 
220
 
        t1 = 16 * src[1] + 15 * src[3] +  9 * src[5] +  4 * src[7];
221
 
        t2 = 15 * src[1] -  4 * src[3] - 16 * src[5] -  9 * src[7];
222
 
        t3 =  9 * src[1] - 16 * src[3] +  4 * src[5] + 15 * src[7];
223
 
        t4 =  4 * src[1] -  9 * src[3] + 15 * src[5] - 16 * src[7];
 
221
        t1 = 16 * src[ 8] + 15 * src[24] +  9 * src[40] +  4 * src[56];
 
222
        t2 = 15 * src[ 8] -  4 * src[24] - 16 * src[40] -  9 * src[56];
 
223
        t3 =  9 * src[ 8] - 16 * src[24] +  4 * src[40] + 15 * src[56];
 
224
        t4 =  4 * src[ 8] -  9 * src[24] + 15 * src[40] - 16 * src[56];
224
225
 
225
226
        dst[0] = (t5 + t1) >> 3;
226
227
        dst[1] = (t6 + t2) >> 3;
231
232
        dst[6] = (t6 - t2) >> 3;
232
233
        dst[7] = (t5 - t1) >> 3;
233
234
 
234
 
        src += 8;
 
235
        src += 1;
235
236
        dst += 8;
236
237
    }
237
238
 
238
 
    src = block;
 
239
    src = temp;
239
240
    dst = block;
240
241
    for(i = 0; i < 8; i++){
241
242
        t1 = 12 * (src[ 0] + src[32]) + 64;
253
254
        t3 =  9 * src[ 8] - 16 * src[24] +  4 * src[40] + 15 * src[56];
254
255
        t4 =  4 * src[ 8] -  9 * src[24] + 15 * src[40] - 16 * src[56];
255
256
 
256
 
        dst[ 0] = (t5 + t1) >> 7;
257
 
        dst[ 8] = (t6 + t2) >> 7;
258
 
        dst[16] = (t7 + t3) >> 7;
259
 
        dst[24] = (t8 + t4) >> 7;
260
 
        dst[32] = (t8 - t4 + 1) >> 7;
261
 
        dst[40] = (t7 - t3 + 1) >> 7;
262
 
        dst[48] = (t6 - t2 + 1) >> 7;
263
 
        dst[56] = (t5 - t1 + 1) >> 7;
 
257
        dst[ 0] = (((t5 + t1    ) >> 7) - sub) << shl;
 
258
        dst[ 8] = (((t6 + t2    ) >> 7) - sub) << shl;
 
259
        dst[16] = (((t7 + t3    ) >> 7) - sub) << shl;
 
260
        dst[24] = (((t8 + t4    ) >> 7) - sub) << shl;
 
261
        dst[32] = (((t8 - t4 + 1) >> 7) - sub) << shl;
 
262
        dst[40] = (((t7 - t3 + 1) >> 7) - sub) << shl;
 
263
        dst[48] = (((t6 - t2 + 1) >> 7) - sub) << shl;
 
264
        dst[56] = (((t5 - t1 + 1) >> 7) - sub) << shl;
264
265
 
265
266
        src++;
266
267
        dst++;
267
268
    }
268
269
}
269
270
 
 
271
static void vc1_inv_trans_8x8_add_c(uint8_t *dest, int linesize, DCTELEM *block)
 
272
{
 
273
    vc1_inv_trans_8x8_c(block, 0, 0);
 
274
    ff_add_pixels_clamped_c(block, dest, linesize);
 
275
}
 
276
 
 
277
static void vc1_inv_trans_8x8_put_signed_c(uint8_t *dest, int linesize, DCTELEM *block)
 
278
{
 
279
    vc1_inv_trans_8x8_c(block, 0, 0);
 
280
    ff_put_signed_pixels_clamped_c(block, dest, linesize);
 
281
}
 
282
 
 
283
static void vc1_inv_trans_8x8_put_signed_rangered_c(uint8_t *dest, int linesize, DCTELEM *block)
 
284
{
 
285
    vc1_inv_trans_8x8_c(block, 1, 0);
 
286
    ff_put_signed_pixels_clamped_c(block, dest, linesize);
 
287
}
 
288
 
 
289
static void vc1_inv_trans_8x8_put_c(uint8_t *dest, int linesize, DCTELEM *block)
 
290
{
 
291
    vc1_inv_trans_8x8_c(block, 0, 0);
 
292
    ff_put_pixels_clamped_c(block, dest, linesize);
 
293
}
 
294
 
 
295
static void vc1_inv_trans_8x8_put_rangered_c(uint8_t *dest, int linesize, DCTELEM *block)
 
296
{
 
297
    vc1_inv_trans_8x8_c(block, 1, 64);
 
298
    ff_put_pixels_clamped_c(block, dest, linesize);
 
299
}
 
300
 
270
301
/** Do inverse transform on 8x4 part of block
271
302
*/
272
303
static void vc1_inv_trans_8x4_dc_c(uint8_t *dest, int linesize, DCTELEM *block)
273
304
{
274
305
    int i;
275
306
    int dc = block[0];
276
 
    const uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
 
307
    const uint8_t *cm;
277
308
    dc = ( 3 * dc +  1) >> 1;
278
309
    dc = (17 * dc + 64) >> 7;
 
310
    cm = ff_cropTbl + MAX_NEG_CROP + dc;
279
311
    for(i = 0; i < 4; i++){
280
 
        dest[0] = cm[dest[0]+dc];
281
 
        dest[1] = cm[dest[1]+dc];
282
 
        dest[2] = cm[dest[2]+dc];
283
 
        dest[3] = cm[dest[3]+dc];
284
 
        dest[4] = cm[dest[4]+dc];
285
 
        dest[5] = cm[dest[5]+dc];
286
 
        dest[6] = cm[dest[6]+dc];
287
 
        dest[7] = cm[dest[7]+dc];
 
312
        dest[0] = cm[dest[0]];
 
313
        dest[1] = cm[dest[1]];
 
314
        dest[2] = cm[dest[2]];
 
315
        dest[3] = cm[dest[3]];
 
316
        dest[4] = cm[dest[4]];
 
317
        dest[5] = cm[dest[5]];
 
318
        dest[6] = cm[dest[6]];
 
319
        dest[7] = cm[dest[7]];
288
320
        dest += linesize;
289
321
    }
290
322
}
350
382
{
351
383
    int i;
352
384
    int dc = block[0];
353
 
    const uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
 
385
    const uint8_t *cm;
354
386
    dc = (17 * dc +  4) >> 3;
355
387
    dc = (12 * dc + 64) >> 7;
 
388
    cm = ff_cropTbl + MAX_NEG_CROP + dc;
356
389
    for(i = 0; i < 8; i++){
357
 
        dest[0] = cm[dest[0]+dc];
358
 
        dest[1] = cm[dest[1]+dc];
359
 
        dest[2] = cm[dest[2]+dc];
360
 
        dest[3] = cm[dest[3]+dc];
 
390
        dest[0] = cm[dest[0]];
 
391
        dest[1] = cm[dest[1]];
 
392
        dest[2] = cm[dest[2]];
 
393
        dest[3] = cm[dest[3]];
361
394
        dest += linesize;
362
395
    }
363
396
}
423
456
{
424
457
    int i;
425
458
    int dc = block[0];
426
 
    const uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
 
459
    const uint8_t *cm;
427
460
    dc = (17 * dc +  4) >> 3;
428
461
    dc = (17 * dc + 64) >> 7;
 
462
    cm = ff_cropTbl + MAX_NEG_CROP + dc;
429
463
    for(i = 0; i < 4; i++){
430
 
        dest[0] = cm[dest[0]+dc];
431
 
        dest[1] = cm[dest[1]+dc];
432
 
        dest[2] = cm[dest[2]+dc];
433
 
        dest[3] = cm[dest[3]+dc];
 
464
        dest[0] = cm[dest[0]];
 
465
        dest[1] = cm[dest[1]];
 
466
        dest[2] = cm[dest[2]];
 
467
        dest[3] = cm[dest[3]];
434
468
        dest += linesize;
435
469
    }
436
470
}
608
642
PUT_VC1_MSPEL(2, 3)
609
643
PUT_VC1_MSPEL(3, 3)
610
644
 
611
 
av_cold void ff_vc1dsp_init(DSPContext* dsp, AVCodecContext *avctx) {
612
 
    dsp->vc1_inv_trans_8x8 = vc1_inv_trans_8x8_c;
 
645
static void put_no_rnd_vc1_chroma_mc8_c(uint8_t *dst/*align 8*/, uint8_t *src/*align 1*/, int stride, int h, int x, int y){
 
646
    const int A=(8-x)*(8-y);
 
647
    const int B=(  x)*(8-y);
 
648
    const int C=(8-x)*(  y);
 
649
    const int D=(  x)*(  y);
 
650
    int i;
 
651
 
 
652
    assert(x<8 && y<8 && x>=0 && y>=0);
 
653
 
 
654
    for(i=0; i<h; i++)
 
655
    {
 
656
        dst[0] = (A*src[0] + B*src[1] + C*src[stride+0] + D*src[stride+1] + 32 - 4) >> 6;
 
657
        dst[1] = (A*src[1] + B*src[2] + C*src[stride+1] + D*src[stride+2] + 32 - 4) >> 6;
 
658
        dst[2] = (A*src[2] + B*src[3] + C*src[stride+2] + D*src[stride+3] + 32 - 4) >> 6;
 
659
        dst[3] = (A*src[3] + B*src[4] + C*src[stride+3] + D*src[stride+4] + 32 - 4) >> 6;
 
660
        dst[4] = (A*src[4] + B*src[5] + C*src[stride+4] + D*src[stride+5] + 32 - 4) >> 6;
 
661
        dst[5] = (A*src[5] + B*src[6] + C*src[stride+5] + D*src[stride+6] + 32 - 4) >> 6;
 
662
        dst[6] = (A*src[6] + B*src[7] + C*src[stride+6] + D*src[stride+7] + 32 - 4) >> 6;
 
663
        dst[7] = (A*src[7] + B*src[8] + C*src[stride+7] + D*src[stride+8] + 32 - 4) >> 6;
 
664
        dst+= stride;
 
665
        src+= stride;
 
666
    }
 
667
}
 
668
 
 
669
#define avg2(a,b) ((a+b+1)>>1)
 
670
static void avg_no_rnd_vc1_chroma_mc8_c(uint8_t *dst/*align 8*/, uint8_t *src/*align 1*/, int stride, int h, int x, int y){
 
671
    const int A=(8-x)*(8-y);
 
672
    const int B=(  x)*(8-y);
 
673
    const int C=(8-x)*(  y);
 
674
    const int D=(  x)*(  y);
 
675
    int i;
 
676
 
 
677
    assert(x<8 && y<8 && x>=0 && y>=0);
 
678
 
 
679
    for(i=0; i<h; i++)
 
680
    {
 
681
        dst[0] = avg2(dst[0], ((A*src[0] + B*src[1] + C*src[stride+0] + D*src[stride+1] + 32 - 4) >> 6));
 
682
        dst[1] = avg2(dst[1], ((A*src[1] + B*src[2] + C*src[stride+1] + D*src[stride+2] + 32 - 4) >> 6));
 
683
        dst[2] = avg2(dst[2], ((A*src[2] + B*src[3] + C*src[stride+2] + D*src[stride+3] + 32 - 4) >> 6));
 
684
        dst[3] = avg2(dst[3], ((A*src[3] + B*src[4] + C*src[stride+3] + D*src[stride+4] + 32 - 4) >> 6));
 
685
        dst[4] = avg2(dst[4], ((A*src[4] + B*src[5] + C*src[stride+4] + D*src[stride+5] + 32 - 4) >> 6));
 
686
        dst[5] = avg2(dst[5], ((A*src[5] + B*src[6] + C*src[stride+5] + D*src[stride+6] + 32 - 4) >> 6));
 
687
        dst[6] = avg2(dst[6], ((A*src[6] + B*src[7] + C*src[stride+6] + D*src[stride+7] + 32 - 4) >> 6));
 
688
        dst[7] = avg2(dst[7], ((A*src[7] + B*src[8] + C*src[stride+7] + D*src[stride+8] + 32 - 4) >> 6));
 
689
        dst+= stride;
 
690
        src+= stride;
 
691
    }
 
692
}
 
693
 
 
694
av_cold void ff_vc1dsp_init(VC1DSPContext* dsp) {
 
695
    dsp->vc1_inv_trans_8x8_add = vc1_inv_trans_8x8_add_c;
 
696
    dsp->vc1_inv_trans_8x8_put_signed[0] = vc1_inv_trans_8x8_put_signed_c;
 
697
    dsp->vc1_inv_trans_8x8_put_signed[1] = vc1_inv_trans_8x8_put_signed_rangered_c;
 
698
    dsp->vc1_inv_trans_8x8_put[0] = vc1_inv_trans_8x8_put_c;
 
699
    dsp->vc1_inv_trans_8x8_put[1] = vc1_inv_trans_8x8_put_rangered_c;
613
700
    dsp->vc1_inv_trans_4x8 = vc1_inv_trans_4x8_c;
614
701
    dsp->vc1_inv_trans_8x4 = vc1_inv_trans_8x4_c;
615
702
    dsp->vc1_inv_trans_4x4 = vc1_inv_trans_4x4_c;
626
713
    dsp->vc1_v_loop_filter16 = vc1_v_loop_filter16_c;
627
714
    dsp->vc1_h_loop_filter16 = vc1_h_loop_filter16_c;
628
715
 
629
 
    dsp->put_vc1_mspel_pixels_tab[ 0] = ff_put_vc1_mspel_mc00_c;
 
716
    dsp->put_vc1_mspel_pixels_tab[ 0] = ff_put_pixels8x8_c;
630
717
    dsp->put_vc1_mspel_pixels_tab[ 1] = put_vc1_mspel_mc10_c;
631
718
    dsp->put_vc1_mspel_pixels_tab[ 2] = put_vc1_mspel_mc20_c;
632
719
    dsp->put_vc1_mspel_pixels_tab[ 3] = put_vc1_mspel_mc30_c;
643
730
    dsp->put_vc1_mspel_pixels_tab[14] = put_vc1_mspel_mc23_c;
644
731
    dsp->put_vc1_mspel_pixels_tab[15] = put_vc1_mspel_mc33_c;
645
732
 
646
 
    dsp->avg_vc1_mspel_pixels_tab[ 0] = ff_avg_vc1_mspel_mc00_c;
 
733
    dsp->avg_vc1_mspel_pixels_tab[ 0] = ff_avg_pixels8x8_c;
647
734
    dsp->avg_vc1_mspel_pixels_tab[ 1] = avg_vc1_mspel_mc10_c;
648
735
    dsp->avg_vc1_mspel_pixels_tab[ 2] = avg_vc1_mspel_mc20_c;
649
736
    dsp->avg_vc1_mspel_pixels_tab[ 3] = avg_vc1_mspel_mc30_c;
659
746
    dsp->avg_vc1_mspel_pixels_tab[13] = avg_vc1_mspel_mc13_c;
660
747
    dsp->avg_vc1_mspel_pixels_tab[14] = avg_vc1_mspel_mc23_c;
661
748
    dsp->avg_vc1_mspel_pixels_tab[15] = avg_vc1_mspel_mc33_c;
 
749
 
 
750
    dsp->put_no_rnd_vc1_chroma_pixels_tab[0]= put_no_rnd_vc1_chroma_mc8_c;
 
751
    dsp->avg_no_rnd_vc1_chroma_pixels_tab[0]= avg_no_rnd_vc1_chroma_mc8_c;
 
752
 
 
753
    if (HAVE_ALTIVEC)
 
754
        ff_vc1dsp_init_altivec(dsp);
 
755
    if (HAVE_MMX)
 
756
        ff_vc1dsp_init_mmx(dsp);
662
757
}