sipsorcery/src/VP8.Net/idct_blk.cs at master · sipsorcery-org/sipsorcery · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
//-----------------------------------------------------------------------------
// Filename: idct_blk.cs
//
// Description: Port of:
//  - idct_blk.c
//
// Author(s):
// Aaron Clauson (aaron@sipsorcery.com)
//
// History:
// 09 Nov 2020	Aaron Clauson	Created, Dublin, Ireland.
//
// License:
// BSD 3-Clause "New" or "Revised" License, see included LICENSE.md file.
//-----------------------------------------------------------------------------

/*
 *  Copyright (c) 2010 The WebM project authors. All Rights Reserved.
 *
 *  Use of this source code is governed by a BSD-style license
 *  that can be found in the LICENSE file in the root of the source
 *  tree. An additional intellectual property rights grant can be found
 *  in the file PATENTS.  All contributing project authors may
 *  be found in the AUTHORS file in the root of the source tree.
 */

namespace Vpx.Net
{
    public static unsafe class idct_blk
    {
        public static void vp8_dequant_idct_add_y_block_c(short* q, short* dq, byte* dst,
                                    int stride, sbyte* eobs)
        {
            int i, j;

            for (i = 0; i < 4; ++i)
            {
                for (j = 0; j < 4; ++j)
                {
                    if (*eobs++ > 1)
                    {
                        dequantize.vp8_dequant_idct_add_c(q, dq, dst, stride);
                    }
                    else
                    {
                        idctllm.vp8_dc_only_idct_add_c((short)(q[0] * dq[0]), dst, stride, dst, stride);
                        //memset(q, 0, 2 * sizeof(q[0]));
                        Mem.memset<short>(q, 0, 2);
                    }

                    q += 16;
                    dst += 4;
                }

                dst += 4 * stride - 16;
            }
        }

        public static void vp8_dequant_idct_add_uv_block_c(short* q, short* dq, byte* dst_u,
                                    byte* dst_v, int stride, sbyte* eobs)
        {
            int i, j;

            for (i = 0; i < 2; ++i)
            {
                for (j = 0; j < 2; ++j)
                {
                    if (*eobs++ > 1)
                    {
                        dequantize.vp8_dequant_idct_add_c(q, dq, dst_u, stride);
                    }
                    else
                    {
                        idctllm.vp8_dc_only_idct_add_c((short)(q[0] * dq[0]), dst_u, stride, dst_u, stride);
                        //memset(q, 0, 2 * sizeof(q[0]));
                        Mem.memset<short>(q, 0, 2);
                    }

                    q += 16;
                    dst_u += 4;
                }

                dst_u += 4 * stride - 8;
            }

            for (i = 0; i < 2; ++i)
            {
                for (j = 0; j < 2; ++j)
                {
                    if (*eobs++ > 1)
                    {
                        dequantize.vp8_dequant_idct_add_c(q, dq, dst_v, stride);
                    }
                    else
                    {
                        idctllm.vp8_dc_only_idct_add_c((short)(q[0] * dq[0]), dst_v, stride, dst_v, stride);
                        //memset(q, 0, 2 * sizeof(q[0]));
                        Mem.memset<short>(q, 0, 2);
                    }

                    q += 16;
                    dst_v += 4;
                }

                dst_v += 4 * stride - 8;
            }
        }
    }
}