/src/libhevc/common/ihevc_padding.c

Source (jump to first uncovered line)
/******************************************************************************
*
* Copyright (C) 2012 Ittiam Systems Pvt Ltd, Bangalore
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at:
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
******************************************************************************/
/**
*******************************************************************************
* @file
*  ihevc_padding.c
*
* @brief
*  Contains function definitions for Padding
*
* @author
*  Srinivas T
*
* @par List of Functions:
*   - ihevc_pad_horz_luma()
*   - ihevc_pad_horz_chroma()
*   - ihevc_pad_vert()
*   - ihevc_pad_left_luma()
*   - ihevc_pad_left_chroma()
*   - ihevc_pad_right_luma()
*   - ihevc_pad_right_chroma()
*   - ihevc_pad_top()
*   - ihevc_pad_bottom()
*
* @remarks
*  None
*
*******************************************************************************
*/

#include <string.h>
#include "ihevc_typedefs.h"
#include "ihevc_func_selector.h"
#include "ihevc_platform_macros.h"
#include "ihevc_mem_fns.h"
/**
*******************************************************************************
*
* @brief
*       Padding function for horizontal input variable
*
* @par Description:
*
*
* @param[in] pu1_src
*  UWORD8 pointer to the source
*
* @param[in] src_strd
*  integer source stride
*
* @param[in] ht
*  integer height of the array
*
* @param[in] wd
*  integer width of the array
*
* @param[in] pad_size
*  integer -padding size of the array
*
* @param[in] ht
*  integer height of the array
*
* @param[in] wd
*  integer width of the array
*
* @returns
*
* @remarks
*  None
*
*******************************************************************************
*/

void ihevc_pad_vert(UWORD8 *pu1_src,
                    WORD32 src_strd,
                    WORD32 ht,
                    WORD32 wd,
                    WORD32 pad_size)
{
    WORD32 row;

    for(row = 1; row <= pad_size; row++)
    {
        memcpy(pu1_src - row * src_strd, pu1_src, wd);
        memcpy(pu1_src + (ht + row - 1) * src_strd,
               pu1_src + (ht - 1) * src_strd, wd);
    }
}

/**
*******************************************************************************
*
* @brief
*   Padding function for vertical input variable
*
* @par Description:
*
*
* @param[in] pu1_src
*  UWORD8 pointer to the source
*
* @param[in] src_strd
*  integer source stride
*
* @param[in] ht
*  integer height of the array
*
* @param[in] wd
*  integer width of the array
*
* @param[in] pad_size
*  integer -padding size of the array
*
* @param[in] ht
*  integer height of the array
*
* @param[in] wd
*  integer width of the array
*
* @returns
*
* @remarks
*  None
*
*******************************************************************************
*/

void ihevc_pad_horz_chroma(UWORD8 *pu1_src,
                           WORD32 src_strd,
                           WORD32 ht,
                           WORD32 wd,
                           WORD32 pad_size)
{
    WORD32 row;
    //WORD32 col;
    UWORD16 *pu2_src = (UWORD16 *)pu1_src;

    src_strd >>= 1;
    wd >>= 1;
    pad_size >>= 1;

    for(row = 0; row < ht; row++)
    {
        UWORD16 u2_uv_val;

        u2_uv_val = pu2_src[0];
        ihevc_memset_16bit(&pu2_src[-pad_size], u2_uv_val, pad_size);

        u2_uv_val = pu2_src[wd - 1];
        ihevc_memset_16bit(&pu2_src[wd], u2_uv_val, pad_size);

        pu2_src += src_strd;
    }
}


/**
*******************************************************************************
*
* @brief
*   Padding function for vertical input variable
*
* @par Description:
*
*
* @param[in] pu1_src
*  UWORD8 pointer to the source
*
* @param[in] src_strd
*  integer source stride
*
* @param[in] ht
*  integer height of the array
*
* @param[in] wd
*  integer width of the array
*
* @param[in] pad_size
*  integer -padding size of the array
*
* @param[in] ht
*  integer height of the array
*
* @param[in] wd
*  integer width of the array
*
* @returns
*
* @remarks
*  None
*
*******************************************************************************
*/

void ihevc_pad_horz_luma(UWORD8 *pu1_src,
                         WORD32 src_strd,
                         WORD32 ht,
                         WORD32 wd,
                         WORD32 pad_size)
{
    WORD32 row;

    for(row = 0; row < ht; row++)
    {
        memset(pu1_src - pad_size, *pu1_src, pad_size);
        memset(pu1_src + wd, *(pu1_src + wd - 1), pad_size);

        pu1_src += src_strd;
    }
}



/**
*******************************************************************************
*
* @brief
*       Padding at the top of a 2d array
*
* @par Description:
*       The top row of a 2d array is replicated for pad_size times at the top
*
*
* @param[in] pu1_src
*  UWORD8 pointer to the source
*
* @param[in] src_strd
*  integer source stride
*
* @param[in] ht
*  integer height of the array
*
* @param[in] wd
*  integer width of the array
*
* @param[in] pad_size
*  integer -padding size of the array
*
* @param[in] ht
*  integer height of the array
*
* @param[in] wd
*  integer width of the array
*
* @returns
*
* @remarks
*  None
*
*******************************************************************************
*/

void ihevc_pad_top(UWORD8 *pu1_src,
                   WORD32 src_strd,
                   WORD32 wd,
                   WORD32 pad_size)
{
    WORD32 row;

    for(row = 1; row <= pad_size; row++)
    {
        memcpy(pu1_src - row * src_strd, pu1_src, wd);
    }
}



/**
*******************************************************************************
*
* @brief
*   Padding at the bottom of a 2d array
*
* @par Description:
*   The bottom row of a 2d array is replicated for pad_size times at the bottom
*
*
* @param[in] pu1_src
*  UWORD8 pointer to the source
*
* @param[in] src_strd
*  integer source stride
*
* @param[in] ht
*  integer height of the array
*
* @param[in] wd
*  integer width of the array
*
* @param[in] pad_size
*  integer -padding size of the array
*
* @param[in] ht
*  integer height of the array
*
* @param[in] wd
*  integer width of the array
*
* @returns
*
* @remarks
*  None
*
*******************************************************************************
*/

void ihevc_pad_bottom(UWORD8 *pu1_src,
                      WORD32 src_strd,
                      WORD32 wd,
                      WORD32 pad_size)
{
    WORD32 row;

    for(row = 1; row <= pad_size; row++)
    {
        memcpy(pu1_src + (row - 1) * src_strd,
               pu1_src - 1 * src_strd, wd);
    }
}



/**
*******************************************************************************
*
* @brief
*   Padding (luma block) at the left of a 2d array
*
* @par Description:
*   The left column of a 2d array is replicated for pad_size times at the left
*
*
* @param[in] pu1_src
*  UWORD8 pointer to the source
*
* @param[in] src_strd
*  integer source stride
*
* @param[in] ht
*  integer height of the array
*
* @param[in] wd
*  integer width of the array
*
* @param[in] pad_size
*  integer -padding size of the array
*
* @param[in] ht
*  integer height of the array
*
* @param[in] wd
*  integer width of the array
*
* @returns
*
* @remarks
*  None
*
*******************************************************************************
*/

void ihevc_pad_left_luma(UWORD8 *pu1_src,
                         WORD32 src_strd,
                         WORD32 ht,
                         WORD32 pad_size)
{
    WORD32 row;

    for(row = 0; row < ht; row++)
    {
        memset(pu1_src - pad_size, *pu1_src, pad_size);

        pu1_src += src_strd;
    }
}



/**
*******************************************************************************
*
* @brief
*   Padding (chroma block) at the left of a 2d array
*
* @par Description:
*   The left column of a 2d array is replicated for pad_size times at the left
*
*
* @param[in] pu1_src
*  UWORD8 pointer to the source
*
* @param[in] src_strd
*  integer source stride
*
* @param[in] ht
*  integer height of the array
*
* @param[in] wd
*  integer width of the array (each colour component)
*
* @param[in] pad_size
*  integer -padding size of the array
*
* @param[in] ht
*  integer height of the array
*
* @param[in] wd
*  integer width of the array
*
* @returns
*
* @remarks
*  None
*
*******************************************************************************
*/

void ihevc_pad_left_chroma(UWORD8 *pu1_src,
                           WORD32 src_strd,
                           WORD32 ht,
                           WORD32 pad_size)
{
    WORD32 row;
    WORD32 col;
    UWORD16 *pu2_src = (UWORD16 *)pu1_src;

    src_strd >>= 1;
    pad_size >>= 1;

    for(row = 0; row < ht; row++)
    {
        UWORD16 u2_uv_val;

        u2_uv_val = pu2_src[0];
        for(col = -pad_size; col < 0; col++)
            pu2_src[col] = u2_uv_val;

        pu2_src += src_strd;
    }
}



/**
*******************************************************************************
*
* @brief
* Padding (luma block) at the right of a 2d array
*
* @par Description:
* The right column of a 2d array is replicated for pad_size times at the right
*
*
* @param[in] pu1_src
*  UWORD8 pointer to the source
*
* @param[in] src_strd
*  integer source stride
*
* @param[in] ht
*  integer height of the array
*
* @param[in] wd
*  integer width of the array
*
* @param[in] pad_size
*  integer -padding size of the array
*
* @param[in] ht
*  integer height of the array
*
* @param[in] wd
*  integer width of the array
*
* @returns
*
* @remarks
*  None
*
*******************************************************************************
*/

void ihevc_pad_right_luma(UWORD8 *pu1_src,
                          WORD32 src_strd,
                          WORD32 ht,
                          WORD32 pad_size)
{
    WORD32 row;

    for(row = 0; row < ht; row++)
    {
        memset(pu1_src, *(pu1_src - 1), pad_size);

        pu1_src += src_strd;
    }
}



/**
*******************************************************************************
*
* @brief
* Padding (chroma block) at the right of a 2d array
*
* @par Description:
* The right column of a 2d array is replicated for pad_size times at the right
*
*
* @param[in] pu1_src
*  UWORD8 pointer to the source
*
* @param[in] src_strd
*  integer source stride
*
* @param[in] ht
*  integer height of the array
*
* @param[in] wd
*  integer width of the array (each colour component)
*
* @param[in] pad_size
*  integer -padding size of the array
*
* @param[in] ht
*  integer height of the array
*
* @param[in] wd
*  integer width of the array
*
* @returns
*
* @remarks
*  None
*
*******************************************************************************
*/

void ihevc_pad_right_chroma(UWORD8 *pu1_src,
                            WORD32 src_strd,
                            WORD32 ht,
                            WORD32 pad_size)
{
    WORD32 row;
    WORD32 col;
    UWORD16 *pu2_src = (UWORD16 *)pu1_src;

    src_strd >>= 1;
    pad_size >>= 1;

    for(row = 0; row < ht; row++)
    {
        UWORD16 u2_uv_val;

        u2_uv_val = pu2_src[-1];
        for(col = 0; col < pad_size; col++)
            pu2_src[col] = u2_uv_val;

        pu2_src += src_strd;
    }
}


Coverage Report

Created: 2025-07-23 06:28

Line	Count	Source (jump to first uncovered line)
1		/******************************************************************************
2		*
3		* Copyright (C) 2012 Ittiam Systems Pvt Ltd, Bangalore
4		*
5		* Licensed under the Apache License, Version 2.0 (the "License");
6		* you may not use this file except in compliance with the License.
7		* You may obtain a copy of the License at:
8		*
9		* http://www.apache.org/licenses/LICENSE-2.0
10		*
11		* Unless required by applicable law or agreed to in writing, software
12		* distributed under the License is distributed on an "AS IS" BASIS,
13		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14		* See the License for the specific language governing permissions and
15		* limitations under the License.
16		*
17		******************************************************************************/
18		/**
19		*******************************************************************************
20		* @file
21		* ihevc_padding.c
22		*
23		* @brief
24		* Contains function definitions for Padding
25		*
26		* @author
27		* Srinivas T
28		*
29		* @par List of Functions:
30		* - ihevc_pad_horz_luma()
31		* - ihevc_pad_horz_chroma()
32		* - ihevc_pad_vert()
33		* - ihevc_pad_left_luma()
34		* - ihevc_pad_left_chroma()
35		* - ihevc_pad_right_luma()
36		* - ihevc_pad_right_chroma()
37		* - ihevc_pad_top()
38		* - ihevc_pad_bottom()
39		*
40		* @remarks
41		* None
42		*
43		*******************************************************************************
44		*/
45
46		#include <string.h>
47		#include "ihevc_typedefs.h"
48		#include "ihevc_func_selector.h"
49		#include "ihevc_platform_macros.h"
50		#include "ihevc_mem_fns.h"
51		/**
52		*******************************************************************************
53		*
54		* @brief
55		* Padding function for horizontal input variable
56		*
57		* @par Description:
58		*
59		*
60		* @param[in] pu1_src
61		* UWORD8 pointer to the source
62		*
63		* @param[in] src_strd
64		* integer source stride
65		*
66		* @param[in] ht
67		* integer height of the array
68		*
69		* @param[in] wd
70		* integer width of the array
71		*
72		* @param[in] pad_size
73		* integer -padding size of the array
74		*
75		* @param[in] ht
76		* integer height of the array
77		*
78		* @param[in] wd
79		* integer width of the array
80		*
81		* @returns
82		*
83		* @remarks
84		* None
85		*
86		*******************************************************************************
87		*/
88
89		void ihevc_pad_vert(UWORD8 *pu1_src,
90		WORD32 src_strd,
91		WORD32 ht,
92		WORD32 wd,
93		WORD32 pad_size)
94	0	{
95	0	WORD32 row;
96
97	0	for(row = 1; row <= pad_size; row++)
98	0	{
99	0	memcpy(pu1_src - row * src_strd, pu1_src, wd);
100	0	memcpy(pu1_src + (ht + row - 1) * src_strd,
101	0	pu1_src + (ht - 1) * src_strd, wd);
102	0	}
103	0	}
104
105		/**
106		*******************************************************************************
107		*
108		* @brief
109		* Padding function for vertical input variable
110		*
111		* @par Description:
112		*
113		*
114		* @param[in] pu1_src
115		* UWORD8 pointer to the source
116		*
117		* @param[in] src_strd
118		* integer source stride
119		*
120		* @param[in] ht
121		* integer height of the array
122		*
123		* @param[in] wd
124		* integer width of the array
125		*
126		* @param[in] pad_size
127		* integer -padding size of the array
128		*
129		* @param[in] ht
130		* integer height of the array
131		*
132		* @param[in] wd
133		* integer width of the array
134		*
135		* @returns
136		*
137		* @remarks
138		* None
139		*
140		*******************************************************************************
141		*/
142
143		void ihevc_pad_horz_chroma(UWORD8 *pu1_src,
144		WORD32 src_strd,
145		WORD32 ht,
146		WORD32 wd,
147		WORD32 pad_size)
148	0	{
149	0	WORD32 row;
150		//WORD32 col;
151	0	UWORD16 pu2_src = (UWORD16 )pu1_src;
152
153	0	src_strd >>= 1;
154	0	wd >>= 1;
155	0	pad_size >>= 1;
156
157	0	for(row = 0; row < ht; row++)
158	0	{
159	0	UWORD16 u2_uv_val;
160
161	0	u2_uv_val = pu2_src[0];
162	0	ihevc_memset_16bit(&pu2_src[-pad_size], u2_uv_val, pad_size);
163
164	0	u2_uv_val = pu2_src[wd - 1];
165	0	ihevc_memset_16bit(&pu2_src[wd], u2_uv_val, pad_size);
166
167	0	pu2_src += src_strd;
168	0	}
169	0	}
170
171
172		/**
173		*******************************************************************************
174		*
175		* @brief
176		* Padding function for vertical input variable
177		*
178		* @par Description:
179		*
180		*
181		* @param[in] pu1_src
182		* UWORD8 pointer to the source
183		*
184		* @param[in] src_strd
185		* integer source stride
186		*
187		* @param[in] ht
188		* integer height of the array
189		*
190		* @param[in] wd
191		* integer width of the array
192		*
193		* @param[in] pad_size
194		* integer -padding size of the array
195		*
196		* @param[in] ht
197		* integer height of the array
198		*
199		* @param[in] wd
200		* integer width of the array
201		*
202		* @returns
203		*
204		* @remarks
205		* None
206		*
207		*******************************************************************************
208		*/
209
210		void ihevc_pad_horz_luma(UWORD8 *pu1_src,
211		WORD32 src_strd,
212		WORD32 ht,
213		WORD32 wd,
214		WORD32 pad_size)
215	0	{
216	0	WORD32 row;
217
218	0	for(row = 0; row < ht; row++)
219	0	{
220	0	memset(pu1_src - pad_size, *pu1_src, pad_size);
221	0	memset(pu1_src + wd, *(pu1_src + wd - 1), pad_size);
222
223	0	pu1_src += src_strd;
224	0	}
225	0	}
226
227
228
229		/**
230		*******************************************************************************
231		*
232		* @brief
233		* Padding at the top of a 2d array
234		*
235		* @par Description:
236		* The top row of a 2d array is replicated for pad_size times at the top
237		*
238		*
239		* @param[in] pu1_src
240		* UWORD8 pointer to the source
241		*
242		* @param[in] src_strd
243		* integer source stride
244		*
245		* @param[in] ht
246		* integer height of the array
247		*
248		* @param[in] wd
249		* integer width of the array
250		*
251		* @param[in] pad_size
252		* integer -padding size of the array
253		*
254		* @param[in] ht
255		* integer height of the array
256		*
257		* @param[in] wd
258		* integer width of the array
259		*
260		* @returns
261		*
262		* @remarks
263		* None
264		*
265		*******************************************************************************
266		*/
267
268		void ihevc_pad_top(UWORD8 *pu1_src,
269		WORD32 src_strd,
270		WORD32 wd,
271		WORD32 pad_size)
272	872k	{
273	872k	WORD32 row;
274
275	59.5M	for(row = 1; row <= pad_size; row++)
276	58.6M	{
277	58.6M	memcpy(pu1_src - row * src_strd, pu1_src, wd);
278	58.6M	}
279	872k	}
280
281
282
283		/**
284		*******************************************************************************
285		*
286		* @brief
287		* Padding at the bottom of a 2d array
288		*
289		* @par Description:
290		* The bottom row of a 2d array is replicated for pad_size times at the bottom
291		*
292		*
293		* @param[in] pu1_src
294		* UWORD8 pointer to the source
295		*
296		* @param[in] src_strd
297		* integer source stride
298		*
299		* @param[in] ht
300		* integer height of the array
301		*
302		* @param[in] wd
303		* integer width of the array
304		*
305		* @param[in] pad_size
306		* integer -padding size of the array
307		*
308		* @param[in] ht
309		* integer height of the array
310		*
311		* @param[in] wd
312		* integer width of the array
313		*
314		* @returns
315		*
316		* @remarks
317		* None
318		*
319		*******************************************************************************
320		*/
321
322		void ihevc_pad_bottom(UWORD8 *pu1_src,
323		WORD32 src_strd,
324		WORD32 wd,
325		WORD32 pad_size)
326	872k	{
327	872k	WORD32 row;
328
329	59.5M	for(row = 1; row <= pad_size; row++)
330	58.6M	{
331	58.6M	memcpy(pu1_src + (row - 1) * src_strd,
332	58.6M	pu1_src - 1 * src_strd, wd);
333	58.6M	}
334	872k	}
335
336
337
338		/**
339		*******************************************************************************
340		*
341		* @brief
342		* Padding (luma block) at the left of a 2d array
343		*
344		* @par Description:
345		* The left column of a 2d array is replicated for pad_size times at the left
346		*
347		*
348		* @param[in] pu1_src
349		* UWORD8 pointer to the source
350		*
351		* @param[in] src_strd
352		* integer source stride
353		*
354		* @param[in] ht
355		* integer height of the array
356		*
357		* @param[in] wd
358		* integer width of the array
359		*
360		* @param[in] pad_size
361		* integer -padding size of the array
362		*
363		* @param[in] ht
364		* integer height of the array
365		*
366		* @param[in] wd
367		* integer width of the array
368		*
369		* @returns
370		*
371		* @remarks
372		* None
373		*
374		*******************************************************************************
375		*/
376
377		void ihevc_pad_left_luma(UWORD8 *pu1_src,
378		WORD32 src_strd,
379		WORD32 ht,
380		WORD32 pad_size)
381	641k	{
382	641k	WORD32 row;
383
384	132M	for(row = 0; row < ht; row++)
385	131M	{
386	131M	memset(pu1_src - pad_size, *pu1_src, pad_size);
387
388	131M	pu1_src += src_strd;
389	131M	}
390	641k	}
391
392
393
394		/**
395		*******************************************************************************
396		*
397		* @brief
398		* Padding (chroma block) at the left of a 2d array
399		*
400		* @par Description:
401		* The left column of a 2d array is replicated for pad_size times at the left
402		*
403		*
404		* @param[in] pu1_src
405		* UWORD8 pointer to the source
406		*
407		* @param[in] src_strd
408		* integer source stride
409		*
410		* @param[in] ht
411		* integer height of the array
412		*
413		* @param[in] wd
414		* integer width of the array (each colour component)
415		*
416		* @param[in] pad_size
417		* integer -padding size of the array
418		*
419		* @param[in] ht
420		* integer height of the array
421		*
422		* @param[in] wd
423		* integer width of the array
424		*
425		* @returns
426		*
427		* @remarks
428		* None
429		*
430		*******************************************************************************
431		*/
432
433		void ihevc_pad_left_chroma(UWORD8 *pu1_src,
434		WORD32 src_strd,
435		WORD32 ht,
436		WORD32 pad_size)
437	160k	{
438	160k	WORD32 row;
439	160k	WORD32 col;
440	160k	UWORD16 pu2_src = (UWORD16 )pu1_src;
441
442	160k	src_strd >>= 1;
443	160k	pad_size >>= 1;
444
445	16.6M	for(row = 0; row < ht; row++)
446	16.4M	{
447	16.4M	UWORD16 u2_uv_val;
448
449	16.4M	u2_uv_val = pu2_src[0];
450	676M	for(col = -pad_size; col < 0; col++)
451	659M	pu2_src[col] = u2_uv_val;
452
453	16.4M	pu2_src += src_strd;
454	16.4M	}
455	160k	}
456
457
458
459		/**
460		*******************************************************************************
461		*
462		* @brief
463		* Padding (luma block) at the right of a 2d array
464		*
465		* @par Description:
466		* The right column of a 2d array is replicated for pad_size times at the right
467		*
468		*
469		* @param[in] pu1_src
470		* UWORD8 pointer to the source
471		*
472		* @param[in] src_strd
473		* integer source stride
474		*
475		* @param[in] ht
476		* integer height of the array
477		*
478		* @param[in] wd
479		* integer width of the array
480		*
481		* @param[in] pad_size
482		* integer -padding size of the array
483		*
484		* @param[in] ht
485		* integer height of the array
486		*
487		* @param[in] wd
488		* integer width of the array
489		*
490		* @returns
491		*
492		* @remarks
493		* None
494		*
495		*******************************************************************************
496		*/
497
498		void ihevc_pad_right_luma(UWORD8 *pu1_src,
499		WORD32 src_strd,
500		WORD32 ht,
501		WORD32 pad_size)
502	641k	{
503	641k	WORD32 row;
504
505	132M	for(row = 0; row < ht; row++)
506	131M	{
507	131M	memset(pu1_src, *(pu1_src - 1), pad_size);
508
509	131M	pu1_src += src_strd;
510	131M	}
511	641k	}
512
513
514
515		/**
516		*******************************************************************************
517		*
518		* @brief
519		* Padding (chroma block) at the right of a 2d array
520		*
521		* @par Description:
522		* The right column of a 2d array is replicated for pad_size times at the right
523		*
524		*
525		* @param[in] pu1_src
526		* UWORD8 pointer to the source
527		*
528		* @param[in] src_strd
529		* integer source stride
530		*
531		* @param[in] ht
532		* integer height of the array
533		*
534		* @param[in] wd
535		* integer width of the array (each colour component)
536		*
537		* @param[in] pad_size
538		* integer -padding size of the array
539		*
540		* @param[in] ht
541		* integer height of the array
542		*
543		* @param[in] wd
544		* integer width of the array
545		*
546		* @returns
547		*
548		* @remarks
549		* None
550		*
551		*******************************************************************************
552		*/
553
554		void ihevc_pad_right_chroma(UWORD8 *pu1_src,
555		WORD32 src_strd,
556		WORD32 ht,
557		WORD32 pad_size)
558	160k	{
559	160k	WORD32 row;
560	160k	WORD32 col;
561	160k	UWORD16 pu2_src = (UWORD16 )pu1_src;
562
563	160k	src_strd >>= 1;
564	160k	pad_size >>= 1;
565
566	16.6M	for(row = 0; row < ht; row++)
567	16.4M	{
568	16.4M	UWORD16 u2_uv_val;
569
570	16.4M	u2_uv_val = pu2_src[-1];
571	676M	for(col = 0; col < pad_size; col++)
572	659M	pu2_src[col] = u2_uv_val;
573
574	16.4M	pu2_src += src_strd;
575	16.4M	}
576	160k	}
577