| /* ------------------------------------------------------------------ |
| * Copyright (C) 1998-2009 PacketVideo |
| * |
| * 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. |
| * ------------------------------------------------------------------- |
| */ |
| /* |
| ------------------------------------------------------------------------------ |
| INPUT AND OUTPUT DEFINITIONS |
| |
| Inputs: |
| xpred = x-axis coordinate of the block used for prediction (int) |
| ypred = y-axis coordinate of the block used for prediction (int) |
| pp_dec_u = pointer to the post processing semaphore for chrominance |
| (uint8) |
| pstprcTypPrv = pointer the previous frame's post processing type |
| (uint8) |
| dx = horizontal component of the motion vector (int) |
| dy = vertical component of the motion vector (int) |
| mvwidth = number of blocks per row in the luminance VOP (int) |
| height = luminance VOP height in pixels (int) |
| size = total number of pixel in the current luminance VOP (int) |
| mv_loc = flag indicating location of the motion compensated |
| (x,y) position with respect to the luminance MB (int); |
| 0 -> inside MB, 1 -> outside MB |
| msk_deblock = flag indicating whether to perform deblocking |
| (msk_deblock = 0) or not (msk_deblock = 1) (uint8) |
| |
| Local Stores/Buffers/Pointers Needed: |
| None |
| |
| Global Stores/Buffers/Pointers Needed: |
| None |
| |
| Outputs: |
| None |
| |
| Pointers and Buffers Modified: |
| pp_dec_u contents are the updated semaphore propagation data |
| |
| Local Stores Modified: |
| None |
| |
| Global Stores Modified: |
| None |
| |
| ------------------------------------------------------------------------------ |
| FUNCTION DESCRIPTION |
| |
| This functions performs post processing semaphore propagation processing |
| after chrominance prediction in interframe processing mode. |
| |
| */ |
| |
| |
| /*---------------------------------------------------------------------------- |
| ; INCLUDES |
| ----------------------------------------------------------------------------*/ |
| #include "mp4dec_api.h" |
| #include "mp4def.h" |
| |
| /*---------------------------------------------------------------------------- |
| ; MACROS |
| ; Define module specific macros here |
| ----------------------------------------------------------------------------*/ |
| |
| /*---------------------------------------------------------------------------- |
| ; DEFINES |
| ; Include all pre-processor statements here. Include conditional |
| ; compile variables also. |
| ----------------------------------------------------------------------------*/ |
| |
| /*---------------------------------------------------------------------------- |
| ; LOCAL FUNCTION DEFINITIONS |
| ; Function Prototype declaration |
| ----------------------------------------------------------------------------*/ |
| |
| /*---------------------------------------------------------------------------- |
| ; LOCAL STORE/BUFFER/POINTER DEFINITIONS |
| ; Variable declaration - defined here and used outside this module |
| ----------------------------------------------------------------------------*/ |
| |
| /*---------------------------------------------------------------------------- |
| ; EXTERNAL FUNCTION REFERENCES |
| ; Declare functions defined elsewhere and referenced in this module |
| ----------------------------------------------------------------------------*/ |
| |
| /*---------------------------------------------------------------------------- |
| ; EXTERNAL GLOBAL STORE/BUFFER/POINTER REFERENCES |
| ; Declare variables used in this module but defined elsewhere |
| ----------------------------------------------------------------------------*/ |
| #ifdef PV_POSTPROC_ON |
| #ifdef __cplusplus |
| extern "C" |
| { |
| #endif |
| /*---------------------------------------------------------------------------- |
| ; FUNCTION CODE |
| ----------------------------------------------------------------------------*/ |
| void pp_semaphore_chroma_inter( |
| int xpred, /* i */ |
| int ypred, /* i */ |
| uint8 *pp_dec_u, /* i/o */ |
| uint8 *pstprcTypPrv, /* i */ |
| int dx, /* i */ |
| int dy, /* i */ |
| int mvwidth, /* i */ |
| int height, /* i */ |
| int32 size, /* i */ |
| int mv_loc, /* i */ |
| uint8 msk_deblock /* i */ |
| ) |
| { |
| /*---------------------------------------------------------------------------- |
| ; Define all local variables |
| ----------------------------------------------------------------------------*/ |
| int mmvy, mmvx, nmvy, nmvx; |
| uint8 *pp_prev1, *pp_prev2, *pp_prev3, *pp_prev4; |
| |
| /*---------------------------------------------------------------------------- |
| ; Function body here |
| ----------------------------------------------------------------------------*/ |
| |
| /* 09/28/2000, modify semaphore propagation to */ |
| /* accommodate smart indexing */ |
| mmvx = xpred >> 4; /* block x coor */ |
| nmvx = mmvx; |
| |
| mmvy = ypred >> 4; /* block y coor */ |
| nmvy = mmvy; |
| |
| /* Check if MV is outside the frame */ |
| if (mv_loc == 1) |
| { |
| /* Perform boundary check */ |
| if (nmvx < 0) |
| { |
| nmvx = 0; |
| } |
| else if (nmvx > mvwidth - 1) |
| { |
| nmvx = mvwidth - 1; |
| } |
| |
| if (nmvy < 0) |
| { |
| nmvy = 0; |
| } |
| else if (nmvy > (height >> 4) - 1) |
| { |
| nmvy = (height >> 4) - 1; |
| } |
| } |
| |
| /* Calculate pointer to first chrominance b semaphores in */ |
| /* pstprcTypPrv, i.e., first chrominance b semaphore is in */ |
| /* (pstprcTypPrv + (size>>6)). */ |
| /* Since total number of chrominance blocks per row in a VOP */ |
| /* is half of the total number of luminance blocks per row in a */ |
| /* VOP, we use (mvwidth >> 1) when calculating the row offset. */ |
| pp_prev1 = pstprcTypPrv + (size >> 6) + nmvx + nmvy * (mvwidth >> 1) ; |
| |
| /* Check if MV is a multiple of 16 */ |
| /* 1/5/01, make sure it doesn't go out of bound */ |
| if (((dy&0xF) != 0) && (mmvy + 1 < (height >> 4) - 1)) |
| { /* dy is not a multiple of 16 */ |
| |
| /* pp_prev3 is the block below pp_prev1 block */ |
| pp_prev3 = pp_prev1 + (mvwidth >> 1); |
| } |
| else |
| { /* dy is a multiple of 16 */ |
| pp_prev3 = pp_prev1; |
| } |
| |
| /* 1/5/01, make sure it doesn't go out of bound */ |
| if (((dx&0xF) != 0) && (mmvx + 1 < (mvwidth >> 1) - 1)) |
| { /* dx is not a multiple of 16 */ |
| |
| /* pp_prev2 is the block to the right of pp_prev1 block */ |
| pp_prev2 = pp_prev1 + 1; |
| |
| /* pp_prev4 is the block to the right of the block */ |
| /* below pp_prev1 block */ |
| pp_prev4 = pp_prev3 + 1; |
| } |
| else |
| { /* dx is a multiple of 16 */ |
| |
| pp_prev2 = pp_prev1; |
| pp_prev4 = pp_prev3; |
| } |
| |
| /* Advance offset to location of first Chrominance R semaphore in */ |
| /* pstprcTypPrv. Since the number of pixels in a Chrominance VOP */ |
| /* is (number of pixels in Luminance VOP/4), and there are 64 */ |
| /* pixels in an 8x8 Chrominance block, the offset can be */ |
| /* calculated as: */ |
| /* mv_loc = (number of pixels in Luminance VOP/(4*64)) */ |
| /* = size/256 = size>>8 */ |
| mv_loc = (size >> 8); |
| |
| /* 11/3/00, change the propagation for deblocking */ |
| if (msk_deblock == 0) |
| { |
| |
| /* Deblocking semaphore propagation for Chrominance */ |
| /* b semaphores */ |
| *(pp_dec_u) = 0; |
| |
| /* Advance offset to point to Chrominance r semaphores */ |
| pp_dec_u += mv_loc; |
| |
| /* Deblocking semaphore propagation for Chrominance */ |
| /* r semaphores */ |
| *(pp_dec_u) = 0; |
| } |
| else |
| { |
| /* Deringing semaphore propagation for Chrominance B block */ |
| if ((*(pp_dec_u)&4) == 0) |
| { |
| *(pp_dec_u) |= ((*(pp_prev1) | *(pp_prev2) | |
| *(pp_prev3) | *(pp_prev4)) & 0x4); |
| } |
| |
| /* Advance offset to point to Chrominance r semaphores */ |
| pp_dec_u += mv_loc; |
| pp_prev1 += mv_loc; |
| pp_prev2 += mv_loc; |
| pp_prev3 += mv_loc; |
| pp_prev4 += mv_loc; |
| |
| /* Deringing semaphore propagation for Chrominance R */ |
| if ((*(pp_dec_u)&4) == 0) |
| { |
| *(pp_dec_u) |= ((*(pp_prev1) | *(pp_prev2) | |
| *(pp_prev3) | *(pp_prev4)) & 0x4); |
| } |
| } |
| |
| /*---------------------------------------------------------------------------- |
| ; Return nothing or data or data pointer |
| ----------------------------------------------------------------------------*/ |
| return; |
| } |
| #ifdef __cplusplus |
| } |
| #endif |
| |
| #endif |
