1749 lines
53 KiB
C
1749 lines
53 KiB
C
#include <string.h>
|
|
#include <stdlib.h>
|
|
#include "mpeg1.h"
|
|
|
|
static const float PICTURE_RATE[] = {
|
|
0.000, 23.976, 24.000, 25.000, 29.970, 30.000, 50.000, 59.940,
|
|
60.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000
|
|
};
|
|
|
|
static const uint8_t ZIG_ZAG[] = {
|
|
0, 1, 8, 16, 9, 2, 3, 10,
|
|
17, 24, 32, 25, 18, 11, 4, 5,
|
|
12, 19, 26, 33, 40, 48, 41, 34,
|
|
27, 20, 13, 6, 7, 14, 21, 28,
|
|
35, 42, 49, 56, 57, 50, 43, 36,
|
|
29, 22, 15, 23, 30, 37, 44, 51,
|
|
58, 59, 52, 45, 38, 31, 39, 46,
|
|
53, 60, 61, 54, 47, 55, 62, 63
|
|
};
|
|
|
|
static const uint8_t DEFAULT_INTRA_QUANT_MATRIX[] = {
|
|
8, 16, 19, 22, 26, 27, 29, 34,
|
|
16, 16, 22, 24, 27, 29, 34, 37,
|
|
19, 22, 26, 27, 29, 34, 34, 38,
|
|
22, 22, 26, 27, 29, 34, 37, 40,
|
|
22, 26, 27, 29, 32, 35, 40, 48,
|
|
26, 27, 29, 32, 35, 40, 48, 58,
|
|
26, 27, 29, 34, 38, 46, 56, 69,
|
|
27, 29, 35, 38, 46, 56, 69, 83
|
|
};
|
|
|
|
static const uint8_t DEFAULT_NON_INTRA_QUANT_MATRIX[] = {
|
|
16, 16, 16, 16, 16, 16, 16, 16,
|
|
16, 16, 16, 16, 16, 16, 16, 16,
|
|
16, 16, 16, 16, 16, 16, 16, 16,
|
|
16, 16, 16, 16, 16, 16, 16, 16,
|
|
16, 16, 16, 16, 16, 16, 16, 16,
|
|
16, 16, 16, 16, 16, 16, 16, 16,
|
|
16, 16, 16, 16, 16, 16, 16, 16,
|
|
16, 16, 16, 16, 16, 16, 16, 16
|
|
};
|
|
|
|
static const uint8_t PREMULTIPLIER_MATRIX[] = {
|
|
32, 44, 42, 38, 32, 25, 17, 9,
|
|
44, 62, 58, 52, 44, 35, 24, 12,
|
|
42, 58, 55, 49, 42, 33, 23, 12,
|
|
38, 52, 49, 44, 38, 30, 20, 10,
|
|
32, 44, 42, 38, 32, 25, 17, 9,
|
|
25, 35, 33, 30, 25, 20, 14, 7,
|
|
17, 24, 23, 20, 17, 14, 9, 5,
|
|
9, 12, 12, 10, 9, 7, 5, 2
|
|
};
|
|
|
|
// MPEG-1 VLC
|
|
|
|
// macroblock_stuffing decodes as 34.
|
|
// macroblock_escape decodes as 35.
|
|
|
|
static const int MACROBLOCK_ADDRESS_INCREMENT[] = {
|
|
1*3, 2*3, 0, // 0
|
|
3*3, 4*3, 0, // 1 0
|
|
0, 0, 1, // 2 1.
|
|
5*3, 6*3, 0, // 3 00
|
|
7*3, 8*3, 0, // 4 01
|
|
9*3, 10*3, 0, // 5 000
|
|
11*3, 12*3, 0, // 6 001
|
|
0, 0, 3, // 7 010.
|
|
0, 0, 2, // 8 011.
|
|
13*3, 14*3, 0, // 9 0000
|
|
15*3, 16*3, 0, // 10 0001
|
|
0, 0, 5, // 11 0010.
|
|
0, 0, 4, // 12 0011.
|
|
17*3, 18*3, 0, // 13 0000 0
|
|
19*3, 20*3, 0, // 14 0000 1
|
|
0, 0, 7, // 15 0001 0.
|
|
0, 0, 6, // 16 0001 1.
|
|
21*3, 22*3, 0, // 17 0000 00
|
|
23*3, 24*3, 0, // 18 0000 01
|
|
25*3, 26*3, 0, // 19 0000 10
|
|
27*3, 28*3, 0, // 20 0000 11
|
|
-1, 29*3, 0, // 21 0000 000
|
|
-1, 30*3, 0, // 22 0000 001
|
|
31*3, 32*3, 0, // 23 0000 010
|
|
33*3, 34*3, 0, // 24 0000 011
|
|
35*3, 36*3, 0, // 25 0000 100
|
|
37*3, 38*3, 0, // 26 0000 101
|
|
0, 0, 9, // 27 0000 110.
|
|
0, 0, 8, // 28 0000 111.
|
|
39*3, 40*3, 0, // 29 0000 0001
|
|
41*3, 42*3, 0, // 30 0000 0011
|
|
43*3, 44*3, 0, // 31 0000 0100
|
|
45*3, 46*3, 0, // 32 0000 0101
|
|
0, 0, 15, // 33 0000 0110.
|
|
0, 0, 14, // 34 0000 0111.
|
|
0, 0, 13, // 35 0000 1000.
|
|
0, 0, 12, // 36 0000 1001.
|
|
0, 0, 11, // 37 0000 1010.
|
|
0, 0, 10, // 38 0000 1011.
|
|
47*3, -1, 0, // 39 0000 0001 0
|
|
-1, 48*3, 0, // 40 0000 0001 1
|
|
49*3, 50*3, 0, // 41 0000 0011 0
|
|
51*3, 52*3, 0, // 42 0000 0011 1
|
|
53*3, 54*3, 0, // 43 0000 0100 0
|
|
55*3, 56*3, 0, // 44 0000 0100 1
|
|
57*3, 58*3, 0, // 45 0000 0101 0
|
|
59*3, 60*3, 0, // 46 0000 0101 1
|
|
61*3, -1, 0, // 47 0000 0001 00
|
|
-1, 62*3, 0, // 48 0000 0001 11
|
|
63*3, 64*3, 0, // 49 0000 0011 00
|
|
65*3, 66*3, 0, // 50 0000 0011 01
|
|
67*3, 68*3, 0, // 51 0000 0011 10
|
|
69*3, 70*3, 0, // 52 0000 0011 11
|
|
71*3, 72*3, 0, // 53 0000 0100 00
|
|
73*3, 74*3, 0, // 54 0000 0100 01
|
|
0, 0, 21, // 55 0000 0100 10.
|
|
0, 0, 20, // 56 0000 0100 11.
|
|
0, 0, 19, // 57 0000 0101 00.
|
|
0, 0, 18, // 58 0000 0101 01.
|
|
0, 0, 17, // 59 0000 0101 10.
|
|
0, 0, 16, // 60 0000 0101 11.
|
|
0, 0, 35, // 61 0000 0001 000. -- macroblock_escape
|
|
0, 0, 34, // 62 0000 0001 111. -- macroblock_stuffing
|
|
0, 0, 33, // 63 0000 0011 000.
|
|
0, 0, 32, // 64 0000 0011 001.
|
|
0, 0, 31, // 65 0000 0011 010.
|
|
0, 0, 30, // 66 0000 0011 011.
|
|
0, 0, 29, // 67 0000 0011 100.
|
|
0, 0, 28, // 68 0000 0011 101.
|
|
0, 0, 27, // 69 0000 0011 110.
|
|
0, 0, 26, // 70 0000 0011 111.
|
|
0, 0, 25, // 71 0000 0100 000.
|
|
0, 0, 24, // 72 0000 0100 001.
|
|
0, 0, 23, // 73 0000 0100 010.
|
|
0, 0, 22 // 74 0000 0100 011.
|
|
};
|
|
|
|
// macroblock_type bitmap:
|
|
// 0x10 macroblock_quant
|
|
// 0x08 macroblock_motion_forward
|
|
// 0x04 macroblock_motion_backward
|
|
// 0x02 macrobkock_pattern
|
|
// 0x01 macroblock_intra
|
|
//
|
|
|
|
static const int MACROBLOCK_TYPE_INTRA[] = {
|
|
1*3, 2*3, 0, // 0
|
|
-1, 3*3, 0, // 1 0
|
|
0, 0, 0x01, // 2 1.
|
|
0, 0, 0x11 // 3 01.
|
|
};
|
|
|
|
static const int MACROBLOCK_TYPE_PREDICTIVE[] = {
|
|
1*3, 2*3, 0, // 0
|
|
3*3, 4*3, 0, // 1 0
|
|
0, 0, 0x0a, // 2 1.
|
|
5*3, 6*3, 0, // 3 00
|
|
0, 0, 0x02, // 4 01.
|
|
7*3, 8*3, 0, // 5 000
|
|
0, 0, 0x08, // 6 001.
|
|
9*3, 10*3, 0, // 7 0000
|
|
11*3, 12*3, 0, // 8 0001
|
|
-1, 13*3, 0, // 9 00000
|
|
0, 0, 0x12, // 10 00001.
|
|
0, 0, 0x1a, // 11 00010.
|
|
0, 0, 0x01, // 12 00011.
|
|
0, 0, 0x11 // 13 000001.
|
|
};
|
|
|
|
static const int MACROBLOCK_TYPE_B[] = {
|
|
1*3, 2*3, 0, // 0
|
|
3*3, 5*3, 0, // 1 0
|
|
4*3, 6*3, 0, // 2 1
|
|
8*3, 7*3, 0, // 3 00
|
|
0, 0, 0x0c, // 4 10.
|
|
9*3, 10*3, 0, // 5 01
|
|
0, 0, 0x0e, // 6 11.
|
|
13*3, 14*3, 0, // 7 001
|
|
12*3, 11*3, 0, // 8 000
|
|
0, 0, 0x04, // 9 010.
|
|
0, 0, 0x06, // 10 011.
|
|
18*3, 16*3, 0, // 11 0001
|
|
15*3, 17*3, 0, // 12 0000
|
|
0, 0, 0x08, // 13 0010.
|
|
0, 0, 0x0a, // 14 0011.
|
|
-1, 19*3, 0, // 15 00000
|
|
0, 0, 0x01, // 16 00011.
|
|
20*3, 21*3, 0, // 17 00001
|
|
0, 0, 0x1e, // 18 00010.
|
|
0, 0, 0x11, // 19 000001.
|
|
0, 0, 0x16, // 20 000010.
|
|
0, 0, 0x1a // 21 000011.
|
|
};
|
|
|
|
static const int *MACROBLOCK_TYPE[] = {
|
|
NULL,
|
|
MACROBLOCK_TYPE_INTRA,
|
|
MACROBLOCK_TYPE_PREDICTIVE,
|
|
MACROBLOCK_TYPE_B
|
|
};
|
|
|
|
static const int CODE_BLOCK_PATTERN[] = {
|
|
2*3, 1*3, 0, // 0
|
|
3*3, 6*3, 0, // 1 1
|
|
4*3, 5*3, 0, // 2 0
|
|
8*3, 11*3, 0, // 3 10
|
|
12*3, 13*3, 0, // 4 00
|
|
9*3, 7*3, 0, // 5 01
|
|
10*3, 14*3, 0, // 6 11
|
|
20*3, 19*3, 0, // 7 011
|
|
18*3, 16*3, 0, // 8 100
|
|
23*3, 17*3, 0, // 9 010
|
|
27*3, 25*3, 0, // 10 110
|
|
21*3, 28*3, 0, // 11 101
|
|
15*3, 22*3, 0, // 12 000
|
|
24*3, 26*3, 0, // 13 001
|
|
0, 0, 60, // 14 111.
|
|
35*3, 40*3, 0, // 15 0000
|
|
44*3, 48*3, 0, // 16 1001
|
|
38*3, 36*3, 0, // 17 0101
|
|
42*3, 47*3, 0, // 18 1000
|
|
29*3, 31*3, 0, // 19 0111
|
|
39*3, 32*3, 0, // 20 0110
|
|
0, 0, 32, // 21 1010.
|
|
45*3, 46*3, 0, // 22 0001
|
|
33*3, 41*3, 0, // 23 0100
|
|
43*3, 34*3, 0, // 24 0010
|
|
0, 0, 4, // 25 1101.
|
|
30*3, 37*3, 0, // 26 0011
|
|
0, 0, 8, // 27 1100.
|
|
0, 0, 16, // 28 1011.
|
|
0, 0, 44, // 29 0111 0.
|
|
50*3, 56*3, 0, // 30 0011 0
|
|
0, 0, 28, // 31 0111 1.
|
|
0, 0, 52, // 32 0110 1.
|
|
0, 0, 62, // 33 0100 0.
|
|
61*3, 59*3, 0, // 34 0010 1
|
|
52*3, 60*3, 0, // 35 0000 0
|
|
0, 0, 1, // 36 0101 1.
|
|
55*3, 54*3, 0, // 37 0011 1
|
|
0, 0, 61, // 38 0101 0.
|
|
0, 0, 56, // 39 0110 0.
|
|
57*3, 58*3, 0, // 40 0000 1
|
|
0, 0, 2, // 41 0100 1.
|
|
0, 0, 40, // 42 1000 0.
|
|
51*3, 62*3, 0, // 43 0010 0
|
|
0, 0, 48, // 44 1001 0.
|
|
64*3, 63*3, 0, // 45 0001 0
|
|
49*3, 53*3, 0, // 46 0001 1
|
|
0, 0, 20, // 47 1000 1.
|
|
0, 0, 12, // 48 1001 1.
|
|
80*3, 83*3, 0, // 49 0001 10
|
|
0, 0, 63, // 50 0011 00.
|
|
77*3, 75*3, 0, // 51 0010 00
|
|
65*3, 73*3, 0, // 52 0000 00
|
|
84*3, 66*3, 0, // 53 0001 11
|
|
0, 0, 24, // 54 0011 11.
|
|
0, 0, 36, // 55 0011 10.
|
|
0, 0, 3, // 56 0011 01.
|
|
69*3, 87*3, 0, // 57 0000 10
|
|
81*3, 79*3, 0, // 58 0000 11
|
|
68*3, 71*3, 0, // 59 0010 11
|
|
70*3, 78*3, 0, // 60 0000 01
|
|
67*3, 76*3, 0, // 61 0010 10
|
|
72*3, 74*3, 0, // 62 0010 01
|
|
86*3, 85*3, 0, // 63 0001 01
|
|
88*3, 82*3, 0, // 64 0001 00
|
|
-1, 94*3, 0, // 65 0000 000
|
|
95*3, 97*3, 0, // 66 0001 111
|
|
0, 0, 33, // 67 0010 100.
|
|
0, 0, 9, // 68 0010 110.
|
|
106*3, 110*3, 0, // 69 0000 100
|
|
102*3, 116*3, 0, // 70 0000 010
|
|
0, 0, 5, // 71 0010 111.
|
|
0, 0, 10, // 72 0010 010.
|
|
93*3, 89*3, 0, // 73 0000 001
|
|
0, 0, 6, // 74 0010 011.
|
|
0, 0, 18, // 75 0010 001.
|
|
0, 0, 17, // 76 0010 101.
|
|
0, 0, 34, // 77 0010 000.
|
|
113*3, 119*3, 0, // 78 0000 011
|
|
103*3, 104*3, 0, // 79 0000 111
|
|
90*3, 92*3, 0, // 80 0001 100
|
|
109*3, 107*3, 0, // 81 0000 110
|
|
117*3, 118*3, 0, // 82 0001 001
|
|
101*3, 99*3, 0, // 83 0001 101
|
|
98*3, 96*3, 0, // 84 0001 110
|
|
100*3, 91*3, 0, // 85 0001 011
|
|
114*3, 115*3, 0, // 86 0001 010
|
|
105*3, 108*3, 0, // 87 0000 101
|
|
112*3, 111*3, 0, // 88 0001 000
|
|
121*3, 125*3, 0, // 89 0000 0011
|
|
0, 0, 41, // 90 0001 1000.
|
|
0, 0, 14, // 91 0001 0111.
|
|
0, 0, 21, // 92 0001 1001.
|
|
124*3, 122*3, 0, // 93 0000 0010
|
|
120*3, 123*3, 0, // 94 0000 0001
|
|
0, 0, 11, // 95 0001 1110.
|
|
0, 0, 19, // 96 0001 1101.
|
|
0, 0, 7, // 97 0001 1111.
|
|
0, 0, 35, // 98 0001 1100.
|
|
0, 0, 13, // 99 0001 1011.
|
|
0, 0, 50, // 100 0001 0110.
|
|
0, 0, 49, // 101 0001 1010.
|
|
0, 0, 58, // 102 0000 0100.
|
|
0, 0, 37, // 103 0000 1110.
|
|
0, 0, 25, // 104 0000 1111.
|
|
0, 0, 45, // 105 0000 1010.
|
|
0, 0, 57, // 106 0000 1000.
|
|
0, 0, 26, // 107 0000 1101.
|
|
0, 0, 29, // 108 0000 1011.
|
|
0, 0, 38, // 109 0000 1100.
|
|
0, 0, 53, // 110 0000 1001.
|
|
0, 0, 23, // 111 0001 0001.
|
|
0, 0, 43, // 112 0001 0000.
|
|
0, 0, 46, // 113 0000 0110.
|
|
0, 0, 42, // 114 0001 0100.
|
|
0, 0, 22, // 115 0001 0101.
|
|
0, 0, 54, // 116 0000 0101.
|
|
0, 0, 51, // 117 0001 0010.
|
|
0, 0, 15, // 118 0001 0011.
|
|
0, 0, 30, // 119 0000 0111.
|
|
0, 0, 39, // 120 0000 0001 0.
|
|
0, 0, 47, // 121 0000 0011 0.
|
|
0, 0, 55, // 122 0000 0010 1.
|
|
0, 0, 27, // 123 0000 0001 1.
|
|
0, 0, 59, // 124 0000 0010 0.
|
|
0, 0, 31 // 125 0000 0011 1.
|
|
};
|
|
|
|
static const int MOTION[] = {
|
|
1*3, 2*3, 0, // 0
|
|
4*3, 3*3, 0, // 1 0
|
|
0, 0, 0, // 2 1.
|
|
6*3, 5*3, 0, // 3 01
|
|
8*3, 7*3, 0, // 4 00
|
|
0, 0, -1, // 5 011.
|
|
0, 0, 1, // 6 010.
|
|
9*3, 10*3, 0, // 7 001
|
|
12*3, 11*3, 0, // 8 000
|
|
0, 0, 2, // 9 0010.
|
|
0, 0, -2, // 10 0011.
|
|
14*3, 15*3, 0, // 11 0001
|
|
16*3, 13*3, 0, // 12 0000
|
|
20*3, 18*3, 0, // 13 0000 1
|
|
0, 0, 3, // 14 0001 0.
|
|
0, 0, -3, // 15 0001 1.
|
|
17*3, 19*3, 0, // 16 0000 0
|
|
-1, 23*3, 0, // 17 0000 00
|
|
27*3, 25*3, 0, // 18 0000 11
|
|
26*3, 21*3, 0, // 19 0000 01
|
|
24*3, 22*3, 0, // 20 0000 10
|
|
32*3, 28*3, 0, // 21 0000 011
|
|
29*3, 31*3, 0, // 22 0000 101
|
|
-1, 33*3, 0, // 23 0000 001
|
|
36*3, 35*3, 0, // 24 0000 100
|
|
0, 0, -4, // 25 0000 111.
|
|
30*3, 34*3, 0, // 26 0000 010
|
|
0, 0, 4, // 27 0000 110.
|
|
0, 0, -7, // 28 0000 0111.
|
|
0, 0, 5, // 29 0000 1010.
|
|
37*3, 41*3, 0, // 30 0000 0100
|
|
0, 0, -5, // 31 0000 1011.
|
|
0, 0, 7, // 32 0000 0110.
|
|
38*3, 40*3, 0, // 33 0000 0011
|
|
42*3, 39*3, 0, // 34 0000 0101
|
|
0, 0, -6, // 35 0000 1001.
|
|
0, 0, 6, // 36 0000 1000.
|
|
51*3, 54*3, 0, // 37 0000 0100 0
|
|
50*3, 49*3, 0, // 38 0000 0011 0
|
|
45*3, 46*3, 0, // 39 0000 0101 1
|
|
52*3, 47*3, 0, // 40 0000 0011 1
|
|
43*3, 53*3, 0, // 41 0000 0100 1
|
|
44*3, 48*3, 0, // 42 0000 0101 0
|
|
0, 0, 10, // 43 0000 0100 10.
|
|
0, 0, 9, // 44 0000 0101 00.
|
|
0, 0, 8, // 45 0000 0101 10.
|
|
0, 0, -8, // 46 0000 0101 11.
|
|
57*3, 66*3, 0, // 47 0000 0011 11
|
|
0, 0, -9, // 48 0000 0101 01.
|
|
60*3, 64*3, 0, // 49 0000 0011 01
|
|
56*3, 61*3, 0, // 50 0000 0011 00
|
|
55*3, 62*3, 0, // 51 0000 0100 00
|
|
58*3, 63*3, 0, // 52 0000 0011 10
|
|
0, 0, -10, // 53 0000 0100 11.
|
|
59*3, 65*3, 0, // 54 0000 0100 01
|
|
0, 0, 12, // 55 0000 0100 000.
|
|
0, 0, 16, // 56 0000 0011 000.
|
|
0, 0, 13, // 57 0000 0011 110.
|
|
0, 0, 14, // 58 0000 0011 100.
|
|
0, 0, 11, // 59 0000 0100 010.
|
|
0, 0, 15, // 60 0000 0011 010.
|
|
0, 0, -16, // 61 0000 0011 001.
|
|
0, 0, -12, // 62 0000 0100 001.
|
|
0, 0, -14, // 63 0000 0011 101.
|
|
0, 0, -15, // 64 0000 0011 011.
|
|
0, 0, -11, // 65 0000 0100 011.
|
|
0, 0, -13 // 66 0000 0011 111.
|
|
};
|
|
|
|
static const int DCT_DC_SIZE_LUMINANCE[] = {
|
|
2*3, 1*3, 0, // 0
|
|
6*3, 5*3, 0, // 1 1
|
|
3*3, 4*3, 0, // 2 0
|
|
0, 0, 1, // 3 00.
|
|
0, 0, 2, // 4 01.
|
|
9*3, 8*3, 0, // 5 11
|
|
7*3, 10*3, 0, // 6 10
|
|
0, 0, 0, // 7 100.
|
|
12*3, 11*3, 0, // 8 111
|
|
0, 0, 4, // 9 110.
|
|
0, 0, 3, // 10 101.
|
|
13*3, 14*3, 0, // 11 1111
|
|
0, 0, 5, // 12 1110.
|
|
0, 0, 6, // 13 1111 0.
|
|
16*3, 15*3, 0, // 14 1111 1
|
|
17*3, -1, 0, // 15 1111 11
|
|
0, 0, 7, // 16 1111 10.
|
|
0, 0, 8 // 17 1111 110.
|
|
};
|
|
|
|
static const int DCT_DC_SIZE_CHROMINANCE[] = {
|
|
2*3, 1*3, 0, // 0
|
|
4*3, 3*3, 0, // 1 1
|
|
6*3, 5*3, 0, // 2 0
|
|
8*3, 7*3, 0, // 3 11
|
|
0, 0, 2, // 4 10.
|
|
0, 0, 1, // 5 01.
|
|
0, 0, 0, // 6 00.
|
|
10*3, 9*3, 0, // 7 111
|
|
0, 0, 3, // 8 110.
|
|
12*3, 11*3, 0, // 9 1111
|
|
0, 0, 4, // 10 1110.
|
|
14*3, 13*3, 0, // 11 1111 1
|
|
0, 0, 5, // 12 1111 0.
|
|
16*3, 15*3, 0, // 13 1111 11
|
|
0, 0, 6, // 14 1111 10.
|
|
17*3, -1, 0, // 15 1111 111
|
|
0, 0, 7, // 16 1111 110.
|
|
0, 0, 8 // 17 1111 1110.
|
|
};
|
|
|
|
// dct_coeff bitmap:
|
|
// 0xff00 run
|
|
// 0x00ff level
|
|
|
|
// Decoded values are unsigned. Sign bit follows in the stream.
|
|
|
|
// Interpretation of the value 0x0001
|
|
// for dc_coeff_first: run=0, level=1
|
|
// for dc_coeff_next: If the next bit is 1: run=0, level=1
|
|
// If the next bit is 0: end_of_block
|
|
|
|
// escape decodes as 0xffff.
|
|
|
|
static const int DCT_COEFF[] = {
|
|
1*3, 2*3, 0, // 0
|
|
4*3, 3*3, 0, // 1 0
|
|
0, 0, 0x0001, // 2 1.
|
|
7*3, 8*3, 0, // 3 01
|
|
6*3, 5*3, 0, // 4 00
|
|
13*3, 9*3, 0, // 5 001
|
|
11*3, 10*3, 0, // 6 000
|
|
14*3, 12*3, 0, // 7 010
|
|
0, 0, 0x0101, // 8 011.
|
|
20*3, 22*3, 0, // 9 0011
|
|
18*3, 21*3, 0, // 10 0001
|
|
16*3, 19*3, 0, // 11 0000
|
|
0, 0, 0x0201, // 12 0101.
|
|
17*3, 15*3, 0, // 13 0010
|
|
0, 0, 0x0002, // 14 0100.
|
|
0, 0, 0x0003, // 15 0010 1.
|
|
27*3, 25*3, 0, // 16 0000 0
|
|
29*3, 31*3, 0, // 17 0010 0
|
|
24*3, 26*3, 0, // 18 0001 0
|
|
32*3, 30*3, 0, // 19 0000 1
|
|
0, 0, 0x0401, // 20 0011 0.
|
|
23*3, 28*3, 0, // 21 0001 1
|
|
0, 0, 0x0301, // 22 0011 1.
|
|
0, 0, 0x0102, // 23 0001 10.
|
|
0, 0, 0x0701, // 24 0001 00.
|
|
0, 0, 0xffff, // 25 0000 01. -- escape
|
|
0, 0, 0x0601, // 26 0001 01.
|
|
37*3, 36*3, 0, // 27 0000 00
|
|
0, 0, 0x0501, // 28 0001 11.
|
|
35*3, 34*3, 0, // 29 0010 00
|
|
39*3, 38*3, 0, // 30 0000 11
|
|
33*3, 42*3, 0, // 31 0010 01
|
|
40*3, 41*3, 0, // 32 0000 10
|
|
52*3, 50*3, 0, // 33 0010 010
|
|
54*3, 53*3, 0, // 34 0010 001
|
|
48*3, 49*3, 0, // 35 0010 000
|
|
43*3, 45*3, 0, // 36 0000 001
|
|
46*3, 44*3, 0, // 37 0000 000
|
|
0, 0, 0x0801, // 38 0000 111.
|
|
0, 0, 0x0004, // 39 0000 110.
|
|
0, 0, 0x0202, // 40 0000 100.
|
|
0, 0, 0x0901, // 41 0000 101.
|
|
51*3, 47*3, 0, // 42 0010 011
|
|
55*3, 57*3, 0, // 43 0000 0010
|
|
60*3, 56*3, 0, // 44 0000 0001
|
|
59*3, 58*3, 0, // 45 0000 0011
|
|
61*3, 62*3, 0, // 46 0000 0000
|
|
0, 0, 0x0a01, // 47 0010 0111.
|
|
0, 0, 0x0d01, // 48 0010 0000.
|
|
0, 0, 0x0006, // 49 0010 0001.
|
|
0, 0, 0x0103, // 50 0010 0101.
|
|
0, 0, 0x0005, // 51 0010 0110.
|
|
0, 0, 0x0302, // 52 0010 0100.
|
|
0, 0, 0x0b01, // 53 0010 0011.
|
|
0, 0, 0x0c01, // 54 0010 0010.
|
|
76*3, 75*3, 0, // 55 0000 0010 0
|
|
67*3, 70*3, 0, // 56 0000 0001 1
|
|
73*3, 71*3, 0, // 57 0000 0010 1
|
|
78*3, 74*3, 0, // 58 0000 0011 1
|
|
72*3, 77*3, 0, // 59 0000 0011 0
|
|
69*3, 64*3, 0, // 60 0000 0001 0
|
|
68*3, 63*3, 0, // 61 0000 0000 0
|
|
66*3, 65*3, 0, // 62 0000 0000 1
|
|
81*3, 87*3, 0, // 63 0000 0000 01
|
|
91*3, 80*3, 0, // 64 0000 0001 01
|
|
82*3, 79*3, 0, // 65 0000 0000 11
|
|
83*3, 86*3, 0, // 66 0000 0000 10
|
|
93*3, 92*3, 0, // 67 0000 0001 10
|
|
84*3, 85*3, 0, // 68 0000 0000 00
|
|
90*3, 94*3, 0, // 69 0000 0001 00
|
|
88*3, 89*3, 0, // 70 0000 0001 11
|
|
0, 0, 0x0203, // 71 0000 0010 11.
|
|
0, 0, 0x0104, // 72 0000 0011 00.
|
|
0, 0, 0x0007, // 73 0000 0010 10.
|
|
0, 0, 0x0402, // 74 0000 0011 11.
|
|
0, 0, 0x0502, // 75 0000 0010 01.
|
|
0, 0, 0x1001, // 76 0000 0010 00.
|
|
0, 0, 0x0f01, // 77 0000 0011 01.
|
|
0, 0, 0x0e01, // 78 0000 0011 10.
|
|
105*3, 107*3, 0, // 79 0000 0000 111
|
|
111*3, 114*3, 0, // 80 0000 0001 011
|
|
104*3, 97*3, 0, // 81 0000 0000 010
|
|
125*3, 119*3, 0, // 82 0000 0000 110
|
|
96*3, 98*3, 0, // 83 0000 0000 100
|
|
-1, 123*3, 0, // 84 0000 0000 000
|
|
95*3, 101*3, 0, // 85 0000 0000 001
|
|
106*3, 121*3, 0, // 86 0000 0000 101
|
|
99*3, 102*3, 0, // 87 0000 0000 011
|
|
113*3, 103*3, 0, // 88 0000 0001 110
|
|
112*3, 116*3, 0, // 89 0000 0001 111
|
|
110*3, 100*3, 0, // 90 0000 0001 000
|
|
124*3, 115*3, 0, // 91 0000 0001 010
|
|
117*3, 122*3, 0, // 92 0000 0001 101
|
|
109*3, 118*3, 0, // 93 0000 0001 100
|
|
120*3, 108*3, 0, // 94 0000 0001 001
|
|
127*3, 136*3, 0, // 95 0000 0000 0010
|
|
139*3, 140*3, 0, // 96 0000 0000 1000
|
|
130*3, 126*3, 0, // 97 0000 0000 0101
|
|
145*3, 146*3, 0, // 98 0000 0000 1001
|
|
128*3, 129*3, 0, // 99 0000 0000 0110
|
|
0, 0, 0x0802, // 100 0000 0001 0001.
|
|
132*3, 134*3, 0, // 101 0000 0000 0011
|
|
155*3, 154*3, 0, // 102 0000 0000 0111
|
|
0, 0, 0x0008, // 103 0000 0001 1101.
|
|
137*3, 133*3, 0, // 104 0000 0000 0100
|
|
143*3, 144*3, 0, // 105 0000 0000 1110
|
|
151*3, 138*3, 0, // 106 0000 0000 1010
|
|
142*3, 141*3, 0, // 107 0000 0000 1111
|
|
0, 0, 0x000a, // 108 0000 0001 0011.
|
|
0, 0, 0x0009, // 109 0000 0001 1000.
|
|
0, 0, 0x000b, // 110 0000 0001 0000.
|
|
0, 0, 0x1501, // 111 0000 0001 0110.
|
|
0, 0, 0x0602, // 112 0000 0001 1110.
|
|
0, 0, 0x0303, // 113 0000 0001 1100.
|
|
0, 0, 0x1401, // 114 0000 0001 0111.
|
|
0, 0, 0x0702, // 115 0000 0001 0101.
|
|
0, 0, 0x1101, // 116 0000 0001 1111.
|
|
0, 0, 0x1201, // 117 0000 0001 1010.
|
|
0, 0, 0x1301, // 118 0000 0001 1001.
|
|
148*3, 152*3, 0, // 119 0000 0000 1101
|
|
0, 0, 0x0403, // 120 0000 0001 0010.
|
|
153*3, 150*3, 0, // 121 0000 0000 1011
|
|
0, 0, 0x0105, // 122 0000 0001 1011.
|
|
131*3, 135*3, 0, // 123 0000 0000 0001
|
|
0, 0, 0x0204, // 124 0000 0001 0100.
|
|
149*3, 147*3, 0, // 125 0000 0000 1100
|
|
172*3, 173*3, 0, // 126 0000 0000 0101 1
|
|
162*3, 158*3, 0, // 127 0000 0000 0010 0
|
|
170*3, 161*3, 0, // 128 0000 0000 0110 0
|
|
168*3, 166*3, 0, // 129 0000 0000 0110 1
|
|
157*3, 179*3, 0, // 130 0000 0000 0101 0
|
|
169*3, 167*3, 0, // 131 0000 0000 0001 0
|
|
174*3, 171*3, 0, // 132 0000 0000 0011 0
|
|
178*3, 177*3, 0, // 133 0000 0000 0100 1
|
|
156*3, 159*3, 0, // 134 0000 0000 0011 1
|
|
164*3, 165*3, 0, // 135 0000 0000 0001 1
|
|
183*3, 182*3, 0, // 136 0000 0000 0010 1
|
|
175*3, 176*3, 0, // 137 0000 0000 0100 0
|
|
0, 0, 0x0107, // 138 0000 0000 1010 1.
|
|
0, 0, 0x0a02, // 139 0000 0000 1000 0.
|
|
0, 0, 0x0902, // 140 0000 0000 1000 1.
|
|
0, 0, 0x1601, // 141 0000 0000 1111 1.
|
|
0, 0, 0x1701, // 142 0000 0000 1111 0.
|
|
0, 0, 0x1901, // 143 0000 0000 1110 0.
|
|
0, 0, 0x1801, // 144 0000 0000 1110 1.
|
|
0, 0, 0x0503, // 145 0000 0000 1001 0.
|
|
0, 0, 0x0304, // 146 0000 0000 1001 1.
|
|
0, 0, 0x000d, // 147 0000 0000 1100 1.
|
|
0, 0, 0x000c, // 148 0000 0000 1101 0.
|
|
0, 0, 0x000e, // 149 0000 0000 1100 0.
|
|
0, 0, 0x000f, // 150 0000 0000 1011 1.
|
|
0, 0, 0x0205, // 151 0000 0000 1010 0.
|
|
0, 0, 0x1a01, // 152 0000 0000 1101 1.
|
|
0, 0, 0x0106, // 153 0000 0000 1011 0.
|
|
180*3, 181*3, 0, // 154 0000 0000 0111 1
|
|
160*3, 163*3, 0, // 155 0000 0000 0111 0
|
|
196*3, 199*3, 0, // 156 0000 0000 0011 10
|
|
0, 0, 0x001b, // 157 0000 0000 0101 00.
|
|
203*3, 185*3, 0, // 158 0000 0000 0010 01
|
|
202*3, 201*3, 0, // 159 0000 0000 0011 11
|
|
0, 0, 0x0013, // 160 0000 0000 0111 00.
|
|
0, 0, 0x0016, // 161 0000 0000 0110 01.
|
|
197*3, 207*3, 0, // 162 0000 0000 0010 00
|
|
0, 0, 0x0012, // 163 0000 0000 0111 01.
|
|
191*3, 192*3, 0, // 164 0000 0000 0001 10
|
|
188*3, 190*3, 0, // 165 0000 0000 0001 11
|
|
0, 0, 0x0014, // 166 0000 0000 0110 11.
|
|
184*3, 194*3, 0, // 167 0000 0000 0001 01
|
|
0, 0, 0x0015, // 168 0000 0000 0110 10.
|
|
186*3, 193*3, 0, // 169 0000 0000 0001 00
|
|
0, 0, 0x0017, // 170 0000 0000 0110 00.
|
|
204*3, 198*3, 0, // 171 0000 0000 0011 01
|
|
0, 0, 0x0019, // 172 0000 0000 0101 10.
|
|
0, 0, 0x0018, // 173 0000 0000 0101 11.
|
|
200*3, 205*3, 0, // 174 0000 0000 0011 00
|
|
0, 0, 0x001f, // 175 0000 0000 0100 00.
|
|
0, 0, 0x001e, // 176 0000 0000 0100 01.
|
|
0, 0, 0x001c, // 177 0000 0000 0100 11.
|
|
0, 0, 0x001d, // 178 0000 0000 0100 10.
|
|
0, 0, 0x001a, // 179 0000 0000 0101 01.
|
|
0, 0, 0x0011, // 180 0000 0000 0111 10.
|
|
0, 0, 0x0010, // 181 0000 0000 0111 11.
|
|
189*3, 206*3, 0, // 182 0000 0000 0010 11
|
|
187*3, 195*3, 0, // 183 0000 0000 0010 10
|
|
218*3, 211*3, 0, // 184 0000 0000 0001 010
|
|
0, 0, 0x0025, // 185 0000 0000 0010 011.
|
|
215*3, 216*3, 0, // 186 0000 0000 0001 000
|
|
0, 0, 0x0024, // 187 0000 0000 0010 100.
|
|
210*3, 212*3, 0, // 188 0000 0000 0001 110
|
|
0, 0, 0x0022, // 189 0000 0000 0010 110.
|
|
213*3, 209*3, 0, // 190 0000 0000 0001 111
|
|
221*3, 222*3, 0, // 191 0000 0000 0001 100
|
|
219*3, 208*3, 0, // 192 0000 0000 0001 101
|
|
217*3, 214*3, 0, // 193 0000 0000 0001 001
|
|
223*3, 220*3, 0, // 194 0000 0000 0001 011
|
|
0, 0, 0x0023, // 195 0000 0000 0010 101.
|
|
0, 0, 0x010b, // 196 0000 0000 0011 100.
|
|
0, 0, 0x0028, // 197 0000 0000 0010 000.
|
|
0, 0, 0x010c, // 198 0000 0000 0011 011.
|
|
0, 0, 0x010a, // 199 0000 0000 0011 101.
|
|
0, 0, 0x0020, // 200 0000 0000 0011 000.
|
|
0, 0, 0x0108, // 201 0000 0000 0011 111.
|
|
0, 0, 0x0109, // 202 0000 0000 0011 110.
|
|
0, 0, 0x0026, // 203 0000 0000 0010 010.
|
|
0, 0, 0x010d, // 204 0000 0000 0011 010.
|
|
0, 0, 0x010e, // 205 0000 0000 0011 001.
|
|
0, 0, 0x0021, // 206 0000 0000 0010 111.
|
|
0, 0, 0x0027, // 207 0000 0000 0010 001.
|
|
0, 0, 0x1f01, // 208 0000 0000 0001 1011.
|
|
0, 0, 0x1b01, // 209 0000 0000 0001 1111.
|
|
0, 0, 0x1e01, // 210 0000 0000 0001 1100.
|
|
0, 0, 0x1002, // 211 0000 0000 0001 0101.
|
|
0, 0, 0x1d01, // 212 0000 0000 0001 1101.
|
|
0, 0, 0x1c01, // 213 0000 0000 0001 1110.
|
|
0, 0, 0x010f, // 214 0000 0000 0001 0011.
|
|
0, 0, 0x0112, // 215 0000 0000 0001 0000.
|
|
0, 0, 0x0111, // 216 0000 0000 0001 0001.
|
|
0, 0, 0x0110, // 217 0000 0000 0001 0010.
|
|
0, 0, 0x0603, // 218 0000 0000 0001 0100.
|
|
0, 0, 0x0b02, // 219 0000 0000 0001 1010.
|
|
0, 0, 0x0e02, // 220 0000 0000 0001 0111.
|
|
0, 0, 0x0d02, // 221 0000 0000 0001 1000.
|
|
0, 0, 0x0c02, // 222 0000 0000 0001 1001.
|
|
0, 0, 0x0f02 // 223 0000 0000 0001 0110.
|
|
};
|
|
|
|
static const int PICTURE_TYPE_INTRA = 1;
|
|
static const int PICTURE_TYPE_PREDICTIVE = 2;
|
|
static const int PICTURE_TYPE_B = 3;
|
|
|
|
static const int START_SEQUENCE = 0xB3;
|
|
static const int START_SLICE_FIRST = 0x01;
|
|
static const int START_SLICE_LAST = 0xAF;
|
|
static const int START_PICTURE = 0x00;
|
|
static const int START_EXTENSION = 0xB5;
|
|
static const int START_USER_DATA = 0xB2;
|
|
|
|
|
|
typedef struct mpeg1_planes_t {
|
|
uint8_t *y;
|
|
uint8_t *cr;
|
|
uint8_t *cb;
|
|
} mpeg1_planes_t;
|
|
|
|
typedef struct mpeg1_decoder_t {
|
|
float frame_rate;
|
|
int width;
|
|
int height;
|
|
int mb_width;
|
|
int mb_height;
|
|
int mb_size;
|
|
|
|
int coded_width;
|
|
int coded_height;
|
|
int coded_size;
|
|
|
|
int half_width;
|
|
int half_height;
|
|
|
|
int picture_type;
|
|
int full_pel_forward;
|
|
int forward_f_code;
|
|
int forward_r_size;
|
|
int forward_f;
|
|
|
|
int has_sequence_header;
|
|
|
|
int quantizer_scale;
|
|
int slice_begin;
|
|
int macroblock_address;
|
|
|
|
int mb_row;
|
|
int mb_col;
|
|
|
|
int macroblock_type;
|
|
int macroblock_intra;
|
|
int macroblock_motion_fw;
|
|
|
|
int motion_fw_h;
|
|
int motion_fw_v;
|
|
int motion_fw_h_prev;
|
|
int motion_fw_v_prev;
|
|
|
|
int dc_predictor_y;
|
|
int dc_predictor_cr;
|
|
int dc_predictor_cb;
|
|
|
|
bit_buffer_t *bits;
|
|
|
|
mpeg1_planes_t planes_current;
|
|
mpeg1_planes_t planes_forward;
|
|
|
|
int block_data[64];
|
|
uint8_t intra_quant_matrix[64];
|
|
uint8_t non_intra_quant_matrix[64];
|
|
} mpeg1_decoder_t;
|
|
|
|
|
|
void decode_sequence_header(mpeg1_decoder_t *self);
|
|
void decode_picture(mpeg1_decoder_t *self);
|
|
void init_buffers(mpeg1_decoder_t *self);
|
|
void decode_slice(mpeg1_decoder_t *self, int slice);
|
|
void decode_macroblock(mpeg1_decoder_t *self);
|
|
void decode_motion_vectors(mpeg1_decoder_t *self);
|
|
void copy_macroblock(mpeg1_decoder_t *self, int motion_h, int motion_v, uint8_t *s_y, uint8_t *s_cr, uint8_t *s_cb);
|
|
void decode_block(mpeg1_decoder_t *self, int block);
|
|
|
|
void copy_block_to_destination(int *block, uint8_t *dest, int index, int scan);
|
|
void add_block_to_destination(int *block, uint8_t *dest, int index, int scan);
|
|
void copy_value_to_destination(int value, uint8_t *dest, int index, int scan);
|
|
void add_value_to_destination(int value, uint8_t *dest, int index, int scan);
|
|
void idct(int *block);
|
|
void zero_block_data(mpeg1_decoder_t *self);
|
|
int read_huffman(bit_buffer_t *bits, const int *code_table);
|
|
|
|
|
|
|
|
|
|
// -----------------------------------------------------------------------------
|
|
// Public interface
|
|
|
|
mpeg1_decoder_t *mpeg1_decoder_create(unsigned int buffer_size, bit_buffer_mode_t buffer_mode) {
|
|
mpeg1_decoder_t *self = malloc(sizeof(mpeg1_decoder_t));
|
|
memset(self, 0, sizeof(mpeg1_decoder_t));
|
|
self->bits = bit_buffer_create(buffer_size, buffer_mode);
|
|
return self;
|
|
}
|
|
|
|
void mpeg1_decoder_destroy(mpeg1_decoder_t *self) {
|
|
bit_buffer_destroy(self->bits);
|
|
|
|
if (self->has_sequence_header) {
|
|
free(self->planes_current.y);
|
|
free(self->planes_current.cr);
|
|
free(self->planes_current.cb);
|
|
|
|
free(self->planes_forward.y);
|
|
free(self->planes_forward.cr);
|
|
free(self->planes_forward.cb);
|
|
}
|
|
|
|
free(self);
|
|
}
|
|
|
|
void *mpeg1_decoder_get_write_ptr(mpeg1_decoder_t *self, unsigned int byte_size) {
|
|
return bit_buffer_get_write_ptr(self->bits, byte_size);
|
|
}
|
|
|
|
int mpeg1_decoder_get_index(mpeg1_decoder_t *self) {
|
|
return bit_buffer_get_index(self->bits);
|
|
}
|
|
|
|
void mpeg1_decoder_set_index(mpeg1_decoder_t *self, unsigned int index) {
|
|
bit_buffer_set_index(self->bits, index);
|
|
}
|
|
|
|
void mpeg1_decoder_did_write(mpeg1_decoder_t *self, unsigned int byte_size) {
|
|
bit_buffer_did_write(self->bits, byte_size);
|
|
if (!self->has_sequence_header) {
|
|
if (bit_buffer_find_start_code(self->bits, START_SEQUENCE) != -1) {
|
|
decode_sequence_header(self);
|
|
}
|
|
}
|
|
}
|
|
|
|
int mpeg1_decoder_has_sequence_header(mpeg1_decoder_t *self) {
|
|
return self->has_sequence_header;
|
|
}
|
|
|
|
float mpeg1_decoder_get_frame_rate(mpeg1_decoder_t *self) {
|
|
return self->frame_rate;
|
|
}
|
|
|
|
int mpeg1_decoder_get_coded_size(mpeg1_decoder_t *self) {
|
|
return self->coded_size;
|
|
}
|
|
|
|
int mpeg1_decoder_get_width(mpeg1_decoder_t *self) {
|
|
return self->width;
|
|
}
|
|
|
|
int mpeg1_decoder_get_height(mpeg1_decoder_t *self) {
|
|
return self->height;
|
|
}
|
|
|
|
void *mpeg1_decoder_get_y_ptr(mpeg1_decoder_t *self) {
|
|
return self->planes_forward.y;
|
|
}
|
|
|
|
void *mpeg1_decoder_get_cr_ptr(mpeg1_decoder_t *self) {
|
|
return self->planes_forward.cr;
|
|
}
|
|
|
|
void *mpeg1_decoder_get_cb_ptr(mpeg1_decoder_t *self) {
|
|
return self->planes_forward.cb;
|
|
}
|
|
|
|
bool mpeg1_decoder_decode(mpeg1_decoder_t *self) {
|
|
if (!self->has_sequence_header) {
|
|
return false;
|
|
}
|
|
|
|
if (bit_buffer_find_start_code(self->bits, START_PICTURE) == -1) {
|
|
return false;
|
|
}
|
|
|
|
decode_picture(self);
|
|
return true;
|
|
}
|
|
|
|
|
|
|
|
|
|
// -----------------------------------------------------------------------------
|
|
// Private methods
|
|
|
|
void decode_sequence_header(mpeg1_decoder_t *self) {
|
|
int previous_width = self->width;
|
|
int previous_height = self->height;
|
|
|
|
self->width = bit_buffer_read(self->bits, 12);
|
|
self->height = bit_buffer_read(self->bits, 12);
|
|
|
|
// skip pixel aspect ratio
|
|
bit_buffer_skip(self->bits, 4);
|
|
|
|
self->frame_rate = PICTURE_RATE[bit_buffer_read(self->bits, 4)];
|
|
|
|
// skip bitRate, marker, bufferSize and constrained bit
|
|
bit_buffer_skip(self->bits, 18 + 1 + 10 + 1);
|
|
|
|
if (bit_buffer_read(self->bits, 1)) { // load custom intra quant matrix?
|
|
for (int i = 0; i < 64; i++) {
|
|
self->intra_quant_matrix[ZIG_ZAG[i]] = bit_buffer_read(self->bits, 8);
|
|
}
|
|
}
|
|
else {
|
|
memcpy(self->intra_quant_matrix, DEFAULT_INTRA_QUANT_MATRIX, 64);
|
|
}
|
|
|
|
if (bit_buffer_read(self->bits, 1)) { // load custom non intra quant matrix?
|
|
for (int i = 0; i < 64; i++) {
|
|
int idx = ZIG_ZAG[i];
|
|
self->non_intra_quant_matrix[idx] = bit_buffer_read(self->bits, 8);
|
|
}
|
|
}
|
|
else {
|
|
memcpy(self->non_intra_quant_matrix, DEFAULT_NON_INTRA_QUANT_MATRIX, 64);
|
|
}
|
|
|
|
if (self->has_sequence_header) {
|
|
if (self->width == previous_width && self->height == previous_height) {
|
|
// We already had a sequence header with the same width/height;
|
|
// nothing else to do here.
|
|
return;
|
|
}
|
|
|
|
// We had a sequence header but with different dimensions;
|
|
// delete the previous planes and allocate new.
|
|
free(self->planes_current.y);
|
|
free(self->planes_current.cr);
|
|
free(self->planes_current.cb);
|
|
|
|
free(self->planes_forward.y);
|
|
free(self->planes_forward.cr);
|
|
free(self->planes_forward.cb);
|
|
}
|
|
|
|
self->mb_width = (self->width + 15) >> 4;
|
|
self->mb_height = (self->height + 15) >> 4;
|
|
self->mb_size = self->mb_width * self->mb_height;
|
|
|
|
self->coded_width = self->mb_width << 4;
|
|
self->coded_height = self->mb_height << 4;
|
|
self->coded_size = self->coded_width * self->coded_height;
|
|
|
|
self->half_width = self->mb_width << 3;
|
|
self->half_height = self->mb_height << 3;
|
|
|
|
self->planes_current.y = (uint8_t*)malloc(self->coded_size);
|
|
self->planes_current.cr = (uint8_t*)malloc(self->coded_size >> 2);
|
|
self->planes_current.cb = (uint8_t*)malloc(self->coded_size >> 2);
|
|
|
|
self->planes_forward.y = (uint8_t*)malloc(self->coded_size);
|
|
self->planes_forward.cr = (uint8_t*)malloc(self->coded_size >> 2);
|
|
self->planes_forward.cb = (uint8_t*)malloc(self->coded_size >> 2);
|
|
|
|
self->has_sequence_header = true;
|
|
}
|
|
|
|
|
|
void decode_picture(mpeg1_decoder_t *self) {
|
|
bit_buffer_skip(self->bits, 10); // skip temporalReference
|
|
self->picture_type = bit_buffer_read(self->bits, 3);
|
|
bit_buffer_skip(self->bits, 16); // skip vbv_delay
|
|
|
|
// Skip B and D frames or unknown coding type
|
|
if (self->picture_type <= 0 || self->picture_type >= PICTURE_TYPE_B) {
|
|
return;
|
|
}
|
|
|
|
// full_pel_forward, forward_f_code
|
|
if (self->picture_type == PICTURE_TYPE_PREDICTIVE) {
|
|
self->full_pel_forward = bit_buffer_read(self->bits, 1);
|
|
self->forward_f_code = bit_buffer_read(self->bits, 3);
|
|
if (self->forward_f_code == 0) {
|
|
// Ignore picture with zero self->forward_f_code
|
|
return;
|
|
}
|
|
self->forward_r_size = self->forward_f_code - 1;
|
|
self->forward_f = 1 << self->forward_r_size;
|
|
}
|
|
|
|
int code = 0;
|
|
do {
|
|
code = bit_buffer_find_next_start_code(self->bits);
|
|
} while (code == START_EXTENSION || code == START_USER_DATA);
|
|
|
|
|
|
while (code >= START_SLICE_FIRST && code <= START_SLICE_LAST) {
|
|
decode_slice(self, code & 0x000000FF);
|
|
code = bit_buffer_find_next_start_code(self->bits);
|
|
}
|
|
|
|
if (code != -1) {
|
|
// We found the next start code; rewind 32self->bits and let the main loop
|
|
// handle it.
|
|
bit_buffer_rewind(self->bits, 32);
|
|
}
|
|
|
|
// If this is a reference picutre then rotate the prediction pointers
|
|
if (
|
|
self->picture_type == PICTURE_TYPE_INTRA ||
|
|
self->picture_type == PICTURE_TYPE_PREDICTIVE
|
|
) {
|
|
mpeg1_planes_t temp = self->planes_forward;
|
|
self->planes_forward = self->planes_current;
|
|
self->planes_current = temp;
|
|
}
|
|
}
|
|
|
|
|
|
// Slice Layer
|
|
|
|
void decode_slice(mpeg1_decoder_t *self, int slice) {
|
|
self->slice_begin = true;
|
|
self->macroblock_address = (slice - 1) * self->mb_width - 1;
|
|
|
|
// Reset motion vectors and DC predictors
|
|
self->motion_fw_h = self->motion_fw_h_prev = 0;
|
|
self->motion_fw_v = self->motion_fw_v_prev = 0;
|
|
self->dc_predictor_y = 128;
|
|
self->dc_predictor_cr = 128;
|
|
self->dc_predictor_cb = 128;
|
|
|
|
self->quantizer_scale = bit_buffer_read(self->bits, 5);
|
|
|
|
// skip extra self->bits
|
|
while (bit_buffer_read(self->bits, 1)) {
|
|
bit_buffer_skip(self->bits, 8);
|
|
}
|
|
|
|
do {
|
|
decode_macroblock(self);
|
|
} while (!bit_buffer_next_bytes_are_start_code(self->bits));
|
|
};
|
|
|
|
|
|
// Macroblock Layer
|
|
|
|
void decode_macroblock(mpeg1_decoder_t *self) {
|
|
// Decode self->macroblock_address_increment
|
|
int increment = 0;
|
|
int x = 0;
|
|
int t = read_huffman(self->bits, MACROBLOCK_ADDRESS_INCREMENT);
|
|
|
|
while (t == 34) {
|
|
// macroblock_stuffing
|
|
x = 1;
|
|
t = read_huffman(self->bits, MACROBLOCK_ADDRESS_INCREMENT);
|
|
}
|
|
while (t == 35) {
|
|
// macroblock_escape
|
|
increment += 33;
|
|
x =
|
|
t = read_huffman(self->bits, MACROBLOCK_ADDRESS_INCREMENT);
|
|
}
|
|
increment += t;
|
|
|
|
// Process any skipped macroblocks
|
|
if (self->slice_begin) {
|
|
// The first self->macroblock_address_increment of each slice is relative
|
|
// to beginning of the preverious row, not the preverious macroblock
|
|
self->slice_begin = false;
|
|
self->macroblock_address += increment;
|
|
}
|
|
else {
|
|
if (self->macroblock_address + increment >= self->mb_size) {
|
|
// Illegal (too large) self->macroblock_address_increment
|
|
// abort();
|
|
return;
|
|
}
|
|
if (increment > 1) {
|
|
// Skipped macroblocks reset DC predictors
|
|
self->dc_predictor_y = 128;
|
|
self->dc_predictor_cr = 128;
|
|
self->dc_predictor_cb = 128;
|
|
|
|
// Skipped macroblocks in P-pictures reset motion vectors
|
|
if (self->picture_type == PICTURE_TYPE_PREDICTIVE) {
|
|
self->motion_fw_h = self->motion_fw_h_prev = 0;
|
|
self->motion_fw_v = self->motion_fw_v_prev = 0;
|
|
}
|
|
}
|
|
|
|
// Predict skipped macroblocks
|
|
while (increment > 1) {
|
|
self->macroblock_address++;
|
|
self->mb_row = (self->macroblock_address / self->mb_width)|0;
|
|
self->mb_col = self->macroblock_address % self->mb_width;
|
|
copy_macroblock(
|
|
self,
|
|
self->motion_fw_h, self->motion_fw_v,
|
|
self->planes_forward.y, self->planes_forward.cr, self->planes_forward.cb
|
|
);
|
|
increment--;
|
|
}
|
|
self->macroblock_address++;
|
|
}
|
|
|
|
self->mb_row = (self->macroblock_address / self->mb_width)|0;
|
|
self->mb_col = self->macroblock_address % self->mb_width;
|
|
|
|
// Process the current macroblock
|
|
// static const s16 *mbTable = MACROBLOCK_TYPE[self->picture_type];
|
|
// macroblock_type = read_huffman(self->bits, mbTable);
|
|
if (self->picture_type == PICTURE_TYPE_INTRA) {
|
|
self->macroblock_type = read_huffman(self->bits, MACROBLOCK_TYPE_INTRA);
|
|
}
|
|
else if (self->picture_type == PICTURE_TYPE_PREDICTIVE) {
|
|
self->macroblock_type = read_huffman(self->bits, MACROBLOCK_TYPE_PREDICTIVE);
|
|
}
|
|
else {
|
|
// Unhandled picture type
|
|
// abort();
|
|
}
|
|
self->macroblock_intra = (self->macroblock_type & 0x01);
|
|
self->macroblock_motion_fw = (self->macroblock_type & 0x08);
|
|
|
|
// Quantizer scale
|
|
if ((self->macroblock_type & 0x10) != 0) {
|
|
self->quantizer_scale = bit_buffer_read(self->bits, 5);
|
|
}
|
|
|
|
if (self->macroblock_intra) {
|
|
// Intra-coded macroblocks reset motion vectors
|
|
self->motion_fw_h = self->motion_fw_h_prev = 0;
|
|
self->motion_fw_v = self->motion_fw_v_prev = 0;
|
|
}
|
|
else {
|
|
// Non-intra macroblocks reset DC predictors
|
|
self->dc_predictor_y = 128;
|
|
self->dc_predictor_cr = 128;
|
|
self->dc_predictor_cb = 128;
|
|
|
|
decode_motion_vectors(self);
|
|
copy_macroblock(
|
|
self,
|
|
self->motion_fw_h, self->motion_fw_v,
|
|
self->planes_forward.y, self->planes_forward.cr, self->planes_forward.cb
|
|
);
|
|
}
|
|
|
|
// Decode blocks
|
|
int cbp = ((self->macroblock_type & 0x02) != 0)
|
|
? read_huffman(self->bits, CODE_BLOCK_PATTERN)
|
|
: (self->macroblock_intra ? 0x3f : 0);
|
|
|
|
for (int block = 0, mask = 0x20; block < 6; block++) {
|
|
if ((cbp & mask) != 0) {
|
|
decode_block(self, block);
|
|
}
|
|
mask >>= 1;
|
|
}
|
|
};
|
|
|
|
|
|
void decode_motion_vectors(mpeg1_decoder_t *self) {
|
|
int code, d, r = 0;
|
|
|
|
// Forward
|
|
if (self->macroblock_motion_fw) {
|
|
// Horizontal forward
|
|
code = read_huffman(self->bits, MOTION);
|
|
if ((code != 0) && (self->forward_f != 1)) {
|
|
r = bit_buffer_read(self->bits, self->forward_r_size);
|
|
d = ((abs(code) - 1) << self->forward_r_size) + r + 1;
|
|
if (code < 0) {
|
|
d = -d;
|
|
}
|
|
}
|
|
else {
|
|
d = code;
|
|
}
|
|
|
|
self->motion_fw_h_prev += d;
|
|
if (self->motion_fw_h_prev > (self->forward_f << 4) - 1) {
|
|
self->motion_fw_h_prev -= self->forward_f << 5;
|
|
}
|
|
else if (self->motion_fw_h_prev < ((-self->forward_f) << 4)) {
|
|
self->motion_fw_h_prev += self->forward_f << 5;
|
|
}
|
|
|
|
self->motion_fw_h = self->motion_fw_h_prev;
|
|
if (self->full_pel_forward) {
|
|
self->motion_fw_h <<= 1;
|
|
}
|
|
|
|
// Vertical forward
|
|
code = read_huffman(self->bits, MOTION);
|
|
if ((code != 0) && (self->forward_f != 1)) {
|
|
r = bit_buffer_read(self->bits, self->forward_r_size);
|
|
d = ((abs(code) - 1) << self->forward_r_size) + r + 1;
|
|
if (code < 0) {
|
|
d = -d;
|
|
}
|
|
}
|
|
else {
|
|
d = code;
|
|
}
|
|
|
|
self->motion_fw_v_prev += d;
|
|
if (self->motion_fw_v_prev > (self->forward_f << 4) - 1) {
|
|
self->motion_fw_v_prev -= self->forward_f << 5;
|
|
}
|
|
else if (self->motion_fw_v_prev < ((-self->forward_f) << 4)) {
|
|
self->motion_fw_v_prev += self->forward_f << 5;
|
|
}
|
|
|
|
self->motion_fw_v = self->motion_fw_v_prev;
|
|
if (self->full_pel_forward) {
|
|
self->motion_fw_v <<= 1;
|
|
}
|
|
}
|
|
else if (self->picture_type == PICTURE_TYPE_PREDICTIVE) {
|
|
// No motion information in P-picture, reset vectors
|
|
self->motion_fw_h = self->motion_fw_h_prev = 0;
|
|
self->motion_fw_v = self->motion_fw_v_prev = 0;
|
|
}
|
|
}
|
|
|
|
|
|
void copy_macroblock(mpeg1_decoder_t *self, int motion_h, int motion_v, uint8_t *s_y, uint8_t *s_cr, uint8_t *s_cb) {
|
|
int
|
|
width, scan,
|
|
H, V,
|
|
src, dest, last;
|
|
bool odd_h, odd_v;
|
|
|
|
// We use 32bit writes here
|
|
int *d_y = (int*)self->planes_current.y;
|
|
int *d_cb = (int*)self->planes_current.cb;
|
|
int *d_cr = (int*)self->planes_current.cr;
|
|
|
|
// Luminance
|
|
width = self->coded_width;
|
|
scan = width - 16;
|
|
|
|
H = motion_h >> 1;
|
|
V = motion_v >> 1;
|
|
odd_h = (motion_h & 1) == 1;
|
|
odd_v = (motion_v & 1) == 1;
|
|
|
|
src = ((self->mb_row << 4) + V) * width + (self->mb_col << 4) + H;
|
|
dest = (self->mb_row * width + self->mb_col) << 2;
|
|
last = dest + (width << 2);
|
|
|
|
int x, y1, y2, y;
|
|
if (odd_h) {
|
|
if (odd_v) {
|
|
while (dest < last) {
|
|
y1 = s_y[src] + s_y[src+width]; src++;
|
|
for (x = 0; x < 4; x++) {
|
|
y2 = s_y[src] + s_y[src+width]; src++;
|
|
y = (((y1 + y2 + 2) >> 2) & 0xff);
|
|
|
|
y1 = s_y[src] + s_y[src+width]; src++;
|
|
y |= (((y1 + y2 + 2) << 6) & 0xff00);
|
|
|
|
y2 = s_y[src] + s_y[src+width]; src++;
|
|
y |= (((y1 + y2 + 2) << 14) & 0xff0000);
|
|
|
|
y1 = s_y[src] + s_y[src+width]; src++;
|
|
y |= (((y1 + y2 + 2) << 22) & 0xff000000);
|
|
|
|
d_y[dest++] = y;
|
|
}
|
|
dest += scan >> 2; src += scan-1;
|
|
}
|
|
}
|
|
else {
|
|
while (dest < last) {
|
|
y1 = s_y[src++];
|
|
for (x = 0; x < 4; x++) {
|
|
y2 = s_y[src++];
|
|
y = (((y1 + y2 + 1) >> 1) & 0xff);
|
|
|
|
y1 = s_y[src++];
|
|
y |= (((y1 + y2 + 1) << 7) & 0xff00);
|
|
|
|
y2 = s_y[src++];
|
|
y |= (((y1 + y2 + 1) << 15) & 0xff0000);
|
|
|
|
y1 = s_y[src++];
|
|
y |= (((y1 + y2 + 1) << 23) & 0xff000000);
|
|
|
|
d_y[dest++] = y;
|
|
}
|
|
dest += scan >> 2; src += scan-1;
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
if (odd_v) {
|
|
while (dest < last) {
|
|
for (x = 0; x < 4; x++) {
|
|
y = (((s_y[src] + s_y[src+width] + 1) >> 1) & 0xff); src++;
|
|
y |= (((s_y[src] + s_y[src+width] + 1) << 7) & 0xff00); src++;
|
|
y |= (((s_y[src] + s_y[src+width] + 1) << 15) & 0xff0000); src++;
|
|
y |= (((s_y[src] + s_y[src+width] + 1) << 23) & 0xff000000); src++;
|
|
|
|
d_y[dest++] = y;
|
|
}
|
|
dest += scan >> 2; src += scan;
|
|
}
|
|
}
|
|
else {
|
|
while (dest < last) {
|
|
for (x = 0; x < 4; x++) {
|
|
y = s_y[src]; src++;
|
|
y |= s_y[src] << 8; src++;
|
|
y |= s_y[src] << 16; src++;
|
|
y |= s_y[src] << 24; src++;
|
|
|
|
d_y[dest++] = y;
|
|
}
|
|
dest += scan >> 2; src += scan;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Chrominance
|
|
|
|
width = self->half_width;
|
|
scan = width - 8;
|
|
|
|
H = (motion_h/2) >> 1;
|
|
V = (motion_v/2) >> 1;
|
|
odd_h = ((motion_h/2) & 1) == 1;
|
|
odd_v = ((motion_v/2) & 1) == 1;
|
|
|
|
src = ((self->mb_row << 3) + V) * width + (self->mb_col << 3) + H;
|
|
dest = (self->mb_row * width + self->mb_col) << 1;
|
|
last = dest + (width << 1);
|
|
|
|
int cr1, cr2, cr,
|
|
cb1, cb2, cb;
|
|
if (odd_h) {
|
|
if (odd_v) {
|
|
while (dest < last) {
|
|
cr1 = s_cr[src] + s_cr[src+width];
|
|
cb1 = s_cb[src] + s_cb[src+width];
|
|
src++;
|
|
for (x = 0; x < 2; x++) {
|
|
cr2 = s_cr[src] + s_cr[src+width];
|
|
cb2 = s_cb[src] + s_cb[src+width]; src++;
|
|
cr = (((cr1 + cr2 + 2) >> 2) & 0xff);
|
|
cb = (((cb1 + cb2 + 2) >> 2) & 0xff);
|
|
|
|
cr1 = s_cr[src] + s_cr[src+width];
|
|
cb1 = s_cb[src] + s_cb[src+width]; src++;
|
|
cr |= (((cr1 + cr2 + 2) << 6) & 0xff00);
|
|
cb |= (((cb1 + cb2 + 2) << 6) & 0xff00);
|
|
|
|
cr2 = s_cr[src] + s_cr[src+width];
|
|
cb2 = s_cb[src] + s_cb[src+width]; src++;
|
|
cr |= (((cr1 + cr2 + 2) << 14) & 0xff0000);
|
|
cb |= (((cb1 + cb2 + 2) << 14) & 0xff0000);
|
|
|
|
cr1 = s_cr[src] + s_cr[src+width];
|
|
cb1 = s_cb[src] + s_cb[src+width]; src++;
|
|
cr |= (((cr1 + cr2 + 2) << 22) & 0xff000000);
|
|
cb |= (((cb1 + cb2 + 2) << 22) & 0xff000000);
|
|
|
|
d_cr[dest] = cr;
|
|
d_cb[dest] = cb;
|
|
dest++;
|
|
}
|
|
dest += scan >> 2; src += scan-1;
|
|
}
|
|
}
|
|
else {
|
|
while (dest < last) {
|
|
cr1 = s_cr[src];
|
|
cb1 = s_cb[src];
|
|
src++;
|
|
for (x = 0; x < 2; x++) {
|
|
cr2 = s_cr[src];
|
|
cb2 = s_cb[src++];
|
|
cr = (((cr1 + cr2 + 1) >> 1) & 0xff);
|
|
cb = (((cb1 + cb2 + 1) >> 1) & 0xff);
|
|
|
|
cr1 = s_cr[src];
|
|
cb1 = s_cb[src++];
|
|
cr |= (((cr1 + cr2 + 1) << 7) & 0xff00);
|
|
cb |= (((cb1 + cb2 + 1) << 7) & 0xff00);
|
|
|
|
cr2 = s_cr[src];
|
|
cb2 = s_cb[src++];
|
|
cr |= (((cr1 + cr2 + 1) << 15) & 0xff0000);
|
|
cb |= (((cb1 + cb2 + 1) << 15) & 0xff0000);
|
|
|
|
cr1 = s_cr[src];
|
|
cb1 = s_cb[src++];
|
|
cr |= (((cr1 + cr2 + 1) << 23) & 0xff000000);
|
|
cb |= (((cb1 + cb2 + 1) << 23) & 0xff000000);
|
|
|
|
d_cr[dest] = cr;
|
|
d_cb[dest] = cb;
|
|
dest++;
|
|
}
|
|
dest += scan >> 2; src += scan-1;
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
if (odd_v) {
|
|
while (dest < last) {
|
|
for (x = 0; x < 2; x++) {
|
|
cr = (((s_cr[src] + s_cr[src+width] + 1) >> 1) & 0xff);
|
|
cb = (((s_cb[src] + s_cb[src+width] + 1) >> 1) & 0xff); src++;
|
|
|
|
cr |= (((s_cr[src] + s_cr[src+width] + 1) << 7) & 0xff00);
|
|
cb |= (((s_cb[src] + s_cb[src+width] + 1) << 7) & 0xff00); src++;
|
|
|
|
cr |= (((s_cr[src] + s_cr[src+width] + 1) << 15) & 0xff0000);
|
|
cb |= (((s_cb[src] + s_cb[src+width] + 1) << 15) & 0xff0000); src++;
|
|
|
|
cr |= (((s_cr[src] + s_cr[src+width] + 1) << 23) & 0xff000000);
|
|
cb |= (((s_cb[src] + s_cb[src+width] + 1) << 23) & 0xff000000); src++;
|
|
|
|
d_cr[dest] = cr;
|
|
d_cb[dest] = cb;
|
|
dest++;
|
|
}
|
|
dest += scan >> 2; src += scan;
|
|
}
|
|
}
|
|
else {
|
|
while (dest < last) {
|
|
for (x = 0; x < 2; x++) {
|
|
cr = s_cr[src];
|
|
cb = s_cb[src]; src++;
|
|
|
|
cr |= s_cr[src] << 8;
|
|
cb |= s_cb[src] << 8; src++;
|
|
|
|
cr |= s_cr[src] << 16;
|
|
cb |= s_cb[src] << 16; src++;
|
|
|
|
cr |= s_cr[src] << 24;
|
|
cb |= s_cb[src] << 24; src++;
|
|
|
|
d_cr[dest] = cr;
|
|
d_cb[dest] = cb;
|
|
dest++;
|
|
}
|
|
dest += scan >> 2; src += scan;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// Block layer
|
|
|
|
void decode_block(mpeg1_decoder_t *self, int block) {
|
|
|
|
int n = 0;
|
|
uint8_t *quant_matrix;
|
|
|
|
// Decode DC coefficient of intra-coded blocks
|
|
if (self->macroblock_intra) {
|
|
int predictor;
|
|
int dctSize;
|
|
|
|
// DC prediction
|
|
|
|
if (block < 4) {
|
|
predictor = self->dc_predictor_y;
|
|
dctSize = read_huffman(self->bits, DCT_DC_SIZE_LUMINANCE);
|
|
}
|
|
else {
|
|
predictor = (block == 4 ? self->dc_predictor_cr : self->dc_predictor_cb);
|
|
dctSize = read_huffman(self->bits, DCT_DC_SIZE_CHROMINANCE);
|
|
}
|
|
|
|
// Read DC coeff
|
|
if (dctSize > 0) {
|
|
int differential = bit_buffer_read(self->bits, dctSize);
|
|
if ((differential & (1 << (dctSize - 1))) != 0) {
|
|
self->block_data[0] = predictor + differential;
|
|
}
|
|
else {
|
|
self->block_data[0] = predictor + ((-1 << dctSize)|(differential+1));
|
|
}
|
|
}
|
|
else {
|
|
self->block_data[0] = predictor;
|
|
}
|
|
|
|
// Save predictor value
|
|
if (block < 4) {
|
|
self->dc_predictor_y = self->block_data[0];
|
|
}
|
|
else if (block == 4) {
|
|
self->dc_predictor_cr = self->block_data[0];
|
|
}
|
|
else {
|
|
self->dc_predictor_cb = self->block_data[0];
|
|
}
|
|
|
|
// Dequantize + premultiply
|
|
self->block_data[0] <<= (3 + 5);
|
|
|
|
quant_matrix = self->intra_quant_matrix;
|
|
n = 1;
|
|
}
|
|
else {
|
|
quant_matrix = self->non_intra_quant_matrix;
|
|
}
|
|
|
|
// Decode AC coefficients (+DC for non-intra)
|
|
int level = 0;
|
|
while (true) {
|
|
int run = 0;
|
|
int coeff = read_huffman(self->bits, DCT_COEFF);
|
|
|
|
if ((coeff == 0x0001) && (n > 0) && (bit_buffer_read(self->bits, 1) == 0)) {
|
|
// end_of_block
|
|
break;
|
|
}
|
|
if (coeff == 0xffff) {
|
|
// escape
|
|
run = bit_buffer_read(self->bits, 6);
|
|
level = bit_buffer_read(self->bits, 8);
|
|
if (level == 0) {
|
|
level = bit_buffer_read(self->bits, 8);
|
|
}
|
|
else if (level == 128) {
|
|
level = bit_buffer_read(self->bits, 8) - 256;
|
|
}
|
|
else if (level > 128) {
|
|
level = level - 256;
|
|
}
|
|
}
|
|
else {
|
|
run = coeff >> 8;
|
|
level = coeff & 0xff;
|
|
if (bit_buffer_read(self->bits, 1)) {
|
|
level = -level;
|
|
}
|
|
}
|
|
|
|
n += run;
|
|
int dezigZagged = ZIG_ZAG[n];
|
|
n++;
|
|
|
|
// Dequantize, oddify, clip
|
|
level <<= 1;
|
|
if (!self->macroblock_intra) {
|
|
level += (level < 0 ? -1 : 1);
|
|
}
|
|
level = (level * self->quantizer_scale * quant_matrix[dezigZagged]) >> 4;
|
|
if ((level & 1) == 0) {
|
|
level -= level > 0 ? 1 : -1;
|
|
}
|
|
if (level > 2047) {
|
|
level = 2047;
|
|
}
|
|
else if (level < -2048) {
|
|
level = -2048;
|
|
}
|
|
|
|
// Save premultiplied coefficient
|
|
self->block_data[dezigZagged] = level * PREMULTIPLIER_MATRIX[dezigZagged];
|
|
}
|
|
|
|
// Move block to its place
|
|
uint8_t *dest_array;
|
|
int dest_index;
|
|
int scan;
|
|
|
|
if (block < 4) {
|
|
dest_array = self->planes_current.y;
|
|
scan = self->coded_width - 8;
|
|
dest_index = (self->mb_row * self->coded_width + self->mb_col) << 4;
|
|
if ((block & 1) != 0) {
|
|
dest_index += 8;
|
|
}
|
|
if ((block & 2) != 0) {
|
|
dest_index += self->coded_width << 3;
|
|
}
|
|
}
|
|
else {
|
|
dest_array = (block == 4) ? self->planes_current.cb : self->planes_current.cr;
|
|
scan = (self->coded_width >> 1) - 8;
|
|
dest_index = ((self->mb_row * self->coded_width) << 2) + (self->mb_col << 3);
|
|
}
|
|
|
|
if (self->macroblock_intra) {
|
|
// Overwrite (no prediction)
|
|
if (n == 1) {
|
|
copy_value_to_destination((self->block_data[0] + 128) >> 8, dest_array, dest_index, scan);
|
|
self->block_data[0] = 0;
|
|
}
|
|
else {
|
|
idct(self->block_data);
|
|
copy_block_to_destination(self->block_data, dest_array, dest_index, scan);
|
|
zero_block_data(self);
|
|
}
|
|
}
|
|
else {
|
|
// Add data to the predicted macroblock
|
|
if (n == 1) {
|
|
add_value_to_destination((self->block_data[0] + 128) >> 8, dest_array, dest_index, scan);
|
|
self->block_data[0] = 0;
|
|
}
|
|
else {
|
|
idct(self->block_data);
|
|
add_block_to_destination(self->block_data, dest_array, dest_index, scan);
|
|
zero_block_data(self);
|
|
}
|
|
}
|
|
|
|
n = 0;
|
|
}
|
|
|
|
|
|
// -----------------------------------------------------------------------------
|
|
// Private functions
|
|
|
|
void zero_block_data(mpeg1_decoder_t *self) {
|
|
for (int i = 0; i < 64; i++) {
|
|
self->block_data[i] = 0;
|
|
}
|
|
}
|
|
|
|
inline uint8_t clamp_to_uint8(int n) {
|
|
return n > 255
|
|
? 255
|
|
: (n < 0 ? 0 : n);
|
|
}
|
|
|
|
void copy_block_to_destination(int *block, uint8_t *dest, int index, int scan) {
|
|
for (int n = 0; n < 64; n += 8, index += scan+8) {
|
|
dest[index+0] = clamp_to_uint8(block[n+0]);
|
|
dest[index+1] = clamp_to_uint8(block[n+1]);
|
|
dest[index+2] = clamp_to_uint8(block[n+2]);
|
|
dest[index+3] = clamp_to_uint8(block[n+3]);
|
|
dest[index+4] = clamp_to_uint8(block[n+4]);
|
|
dest[index+5] = clamp_to_uint8(block[n+5]);
|
|
dest[index+6] = clamp_to_uint8(block[n+6]);
|
|
dest[index+7] = clamp_to_uint8(block[n+7]);
|
|
}
|
|
}
|
|
|
|
void add_block_to_destination(int *block, uint8_t *dest, int index, int scan) {
|
|
for (int n = 0; n < 64; n += 8, index += scan+8) {
|
|
dest[index+0] = clamp_to_uint8(dest[index+0] + block[n+0]);
|
|
dest[index+1] = clamp_to_uint8(dest[index+1] + block[n+1]);
|
|
dest[index+2] = clamp_to_uint8(dest[index+2] + block[n+2]);
|
|
dest[index+3] = clamp_to_uint8(dest[index+3] + block[n+3]);
|
|
dest[index+4] = clamp_to_uint8(dest[index+4] + block[n+4]);
|
|
dest[index+5] = clamp_to_uint8(dest[index+5] + block[n+5]);
|
|
dest[index+6] = clamp_to_uint8(dest[index+6] + block[n+6]);
|
|
dest[index+7] = clamp_to_uint8(dest[index+7] + block[n+7]);
|
|
}
|
|
}
|
|
|
|
void copy_value_to_destination(int value, uint8_t *dest, int index, int scan) {
|
|
value = clamp_to_uint8(value);
|
|
for (int n = 0; n < 64; n += 8, index += scan+8) {
|
|
dest[index+0] = value;
|
|
dest[index+1] = value;
|
|
dest[index+2] = value;
|
|
dest[index+3] = value;
|
|
dest[index+4] = value;
|
|
dest[index+5] = value;
|
|
dest[index+6] = value;
|
|
dest[index+7] = value;
|
|
}
|
|
}
|
|
|
|
void add_value_to_destination(int value, uint8_t *dest, int index, int scan) {
|
|
for (int n = 0; n < 64; n += 8, index += scan+8) {
|
|
dest[index+0] = clamp_to_uint8(dest[index+0] + value);
|
|
dest[index+1] = clamp_to_uint8(dest[index+1] + value);
|
|
dest[index+2] = clamp_to_uint8(dest[index+2] + value);
|
|
dest[index+3] = clamp_to_uint8(dest[index+3] + value);
|
|
dest[index+4] = clamp_to_uint8(dest[index+4] + value);
|
|
dest[index+5] = clamp_to_uint8(dest[index+5] + value);
|
|
dest[index+6] = clamp_to_uint8(dest[index+6] + value);
|
|
dest[index+7] = clamp_to_uint8(dest[index+7] + value);
|
|
}
|
|
}
|
|
|
|
void idct(int *block) {
|
|
// See http://vsr.informatik.tu-chemnitz.de/~jan/MPEG/HTML/IDCT.html
|
|
// for more info.
|
|
|
|
int
|
|
b1, b3, b4, b6, b7, tmp1, tmp2, m0,
|
|
x0, x1, x2, x3, x4, y3, y4, y5, y6, y7;
|
|
|
|
// Transform columns
|
|
for (int i = 0; i < 8; ++i) {
|
|
b1 = block[4*8+i];
|
|
b3 = block[2*8+i] + block[6*8+i];
|
|
b4 = block[5*8+i] - block[3*8+i];
|
|
tmp1 = block[1*8+i] + block[7*8+i];
|
|
tmp2 = block[3*8+i] + block[5*8+i];
|
|
b6 = block[1*8+i] - block[7*8+i];
|
|
b7 = tmp1 + tmp2;
|
|
m0 = block[0*8+i];
|
|
x4 = ((b6*473 - b4*196 + 128) >> 8) - b7;
|
|
x0 = x4 - (((tmp1 - tmp2)*362 + 128) >> 8);
|
|
x1 = m0 - b1;
|
|
x2 = (((block[2*8+i] - block[6*8+i])*362 + 128) >> 8) - b3;
|
|
x3 = m0 + b1;
|
|
y3 = x1 + x2;
|
|
y4 = x3 + b3;
|
|
y5 = x1 - x2;
|
|
y6 = x3 - b3;
|
|
y7 = -x0 - ((b4*473 + b6*196 + 128) >> 8);
|
|
block[0*8+i] = b7 + y4;
|
|
block[1*8+i] = x4 + y3;
|
|
block[2*8+i] = y5 - x0;
|
|
block[3*8+i] = y6 - y7;
|
|
block[4*8+i] = y6 + y7;
|
|
block[5*8+i] = x0 + y5;
|
|
block[6*8+i] = y3 - x4;
|
|
block[7*8+i] = y4 - b7;
|
|
}
|
|
|
|
// Transform rows
|
|
for (int i = 0; i < 64; i += 8) {
|
|
b1 = block[4+i];
|
|
b3 = block[2+i] + block[6+i];
|
|
b4 = block[5+i] - block[3+i];
|
|
tmp1 = block[1+i] + block[7+i];
|
|
tmp2 = block[3+i] + block[5+i];
|
|
b6 = block[1+i] - block[7+i];
|
|
b7 = tmp1 + tmp2;
|
|
m0 = block[0+i];
|
|
x4 = ((b6*473 - b4*196 + 128) >> 8) - b7;
|
|
x0 = x4 - (((tmp1 - tmp2)*362 + 128) >> 8);
|
|
x1 = m0 - b1;
|
|
x2 = (((block[2+i] - block[6+i])*362 + 128) >> 8) - b3;
|
|
x3 = m0 + b1;
|
|
y3 = x1 + x2;
|
|
y4 = x3 + b3;
|
|
y5 = x1 - x2;
|
|
y6 = x3 - b3;
|
|
y7 = -x0 - ((b4*473 + b6*196 + 128) >> 8);
|
|
block[0+i] = (b7 + y4 + 128) >> 8;
|
|
block[1+i] = (x4 + y3 + 128) >> 8;
|
|
block[2+i] = (y5 - x0 + 128) >> 8;
|
|
block[3+i] = (y6 - y7 + 128) >> 8;
|
|
block[4+i] = (y6 + y7 + 128) >> 8;
|
|
block[5+i] = (x0 + y5 + 128) >> 8;
|
|
block[6+i] = (y3 - x4 + 128) >> 8;
|
|
block[7+i] = (y4 - b7 + 128) >> 8;
|
|
}
|
|
}
|
|
|
|
int read_huffman(bit_buffer_t *bits, const int *code_table) {
|
|
int state = 0;
|
|
do {
|
|
state = code_table[state + bit_buffer_read(bits, 1)];
|
|
} while (state >= 0 && code_table[state] != 0);
|
|
return code_table[state+2];
|
|
}
|