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
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
|
/**
*
* File Name: omxVCM4P2_DecodeBlockCoef_Intra.c
* OpenMAX DL: v1.0.2
* Revision: 12290
* Date: Wednesday, April 9, 2008
*
* (c) Copyright 2007-2008 ARM Limited. All Rights Reserved.
*
*
*
* Description:
* Contains modules for intra reconstruction
*
*/
#include "omxtypes.h"
#include "armOMX.h"
#include "omxVC.h"
#include "armCOMM.h"
#include "armVC.h"
/* Function for saturating 16 bit values to the [0,255] range and */
/* writing out as 8 bit values. Does 64 entries */
void armVCM4P2_Clip8(OMX_S16 *pSrc, OMX_U8 *pDst, OMX_INT dstStep );
/**
* Function: omxVCM4P2_DecodeBlockCoef_Intra
*
* Description:
* Decodes the INTRA block coefficients. Inverse quantization, inversely zigzag
* positioning, and IDCT, with appropriate clipping on each step, are performed
* on the coefficients. The results are then placed in the output frame/plane on
* a pixel basis. For INTRA block, the output values are clipped to [0, 255] and
* written to corresponding block buffer within the destination plane.
*
* Remarks:
*
* Parameters:
* [in] ppBitStream pointer to the pointer to the current byte in
* the bit stream buffer. There is no boundary
* check for the bit stream buffer.
* [in] pBitOffset pointer to the bit position in the byte pointed
* to by *ppBitStream. *pBitOffset is valid within
* [0-7].
* [in] step width of the destination plane
* [in/out] pCoefBufRow [in] pointer to the coefficient row buffer
* [out] updated coefficient rwo buffer
* [in/out] pCoefBufCol [in] pointer to the coefficient column buffer
* [out] updated coefficient column buffer
* [in] curQP quantization parameter of the macroblock which
* the current block belongs to
* [in] pQpBuf Pointer to a 2-element QP array. pQpBuf[0] holds the QP of the 8x8 block left to
* the current block(QPa). pQpBuf[1] holds the QP of the 8x8 block just above the
* current block(QPc).
* Note, in case the corresponding block is out of VOP bound, the QP value will have
* no effect to the intra-prediction process. Refer to subclause "7.4.3.3 Adaptive
* ac coefficient prediction" of ISO/IEC 14496-2(MPEG4 Part2) for accurate description.
* [in] blockIndex block index indicating the component type and
* position as defined in subclause 6.1.3.8,
* Figure 6-5 of ISO/IEC 14496-2.
* [in] intraDCVLC a code determined by intra_dc_vlc_thr and QP.
* This allows a mechanism to switch between two VLC
* for coding of Intra DC coefficients as per Table
* 6-21 of ISO/IEC 14496-2.
* [in] ACPredFlag a flag equal to ac_pred_flag (of luminance) indicating
* if the ac coefficients of the first row or first
* column are differentially coded for intra coded
* macroblock.
* [in] shortVideoHeader a flag indicating presence of short_video_header;
* shortVideoHeader==1 selects linear intra DC mode,
* and shortVideoHeader==0 selects nonlinear intra DC mode.
* [out] ppBitStream *ppBitStream is updated after the block is
* decoded, so that it points to the current byte
* in the bit stream buffer
* [out] pBitOffset *pBitOffset is updated so that it points to the
* current bit position in the byte pointed by
* *ppBitStream
* [out] pDst pointer to the block in the destination plane.
* pDst should be 16-byte aligned.
* [out] pCoefBufRow pointer to the updated coefficient row buffer.
*
* Return Value:
* OMX_Sts_NoErr - no error
* OMX_Sts_BadArgErr - bad arguments
* - At least one of the following pointers is NULL: ppBitStream, *ppBitStream, pBitOffset,
* pCoefBufRow, pCoefBufCol, pQPBuf, pDst.
* or
* - At least one of the below case: *pBitOffset exceeds [0,7], curQP exceeds (1, 31),
* blockIndex exceeds [0,9], step is not the multiple of 8, intraDCVLC is zero while
* blockIndex greater than 5.
* or
* - pDst is not 16-byte aligned
* OMX_Sts_Err - status error
*
*/
OMXResult omxVCM4P2_DecodeBlockCoef_Intra(
const OMX_U8 ** ppBitStream,
OMX_INT *pBitOffset,
OMX_U8 *pDst,
OMX_INT step,
OMX_S16 *pCoefBufRow,
OMX_S16 *pCoefBufCol,
OMX_U8 curQP,
const OMX_U8 *pQPBuf,
OMX_INT blockIndex,
OMX_INT intraDCVLC,
OMX_INT ACPredFlag,
OMX_INT shortVideoHeader
)
{
OMX_S16 tempBuf1[79], tempBuf2[79];
OMX_S16 *pTempBuf1, *pTempBuf2;
OMX_INT predDir, predACDir;
OMX_INT predQP;
OMXVCM4P2VideoComponent videoComp;
OMXResult errorCode;
/* Aligning the local buffers */
pTempBuf1 = armAlignTo16Bytes(tempBuf1);
pTempBuf2 = armAlignTo16Bytes(tempBuf2);
/* Setting the AC prediction direction and prediction direction */
armVCM4P2_SetPredDir(
blockIndex,
pCoefBufRow,
pCoefBufCol,
&predDir,
&predQP,
pQPBuf);
predACDir = predDir;
if (ACPredFlag == 0)
{
predACDir = OMX_VC_NONE;
}
/* Setting the videoComp */
if (blockIndex <= 3)
{
videoComp = OMX_VC_LUMINANCE;
}
else
{
videoComp = OMX_VC_CHROMINANCE;
}
/* VLD and zigzag */
if (intraDCVLC == 1)
{
errorCode = omxVCM4P2_DecodeVLCZigzag_IntraDCVLC(
ppBitStream,
pBitOffset,
pTempBuf1,
predACDir,
shortVideoHeader,
videoComp);
armRetDataErrIf((errorCode != OMX_Sts_NoErr), errorCode);
}
else
{
errorCode = omxVCM4P2_DecodeVLCZigzag_IntraACVLC(
ppBitStream,
pBitOffset,
pTempBuf1,
predACDir,
shortVideoHeader);
armRetDataErrIf((errorCode != OMX_Sts_NoErr), errorCode);
}
/* AC DC prediction */
errorCode = omxVCM4P2_PredictReconCoefIntra(
pTempBuf1,
pCoefBufRow,
pCoefBufCol,
curQP,
predQP,
predDir,
ACPredFlag,
videoComp);
armRetDataErrIf((errorCode != OMX_Sts_NoErr), errorCode);
/* Dequantization */
errorCode = omxVCM4P2_QuantInvIntra_I(
pTempBuf1,
curQP,
videoComp,
shortVideoHeader);
armRetDataErrIf((errorCode != OMX_Sts_NoErr), errorCode);
/* Inverse transform */
errorCode = omxVCM4P2_IDCT8x8blk (pTempBuf1, pTempBuf2);
armRetDataErrIf((errorCode != OMX_Sts_NoErr), errorCode);
/* Placing the linear array into the destination plane and clipping
it to 0 to 255 */
armVCM4P2_Clip8(pTempBuf2,pDst,step);
return OMX_Sts_NoErr;
}
/* End of file */
|
