Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with
or
.
Download ZIP
tree: 33409ef7bb
Fetching contributors…

Cannot retrieve contributors at this time

472 lines (417 sloc) 14.812 kb
/* ------------------------------------------------------------------
* 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.
* -------------------------------------------------------------------
*/
#include <string.h>
#include "avclib_common.h"
OSCL_EXPORT_REF void InitNeighborAvailability(AVCCommonObj *video, int mbNum)
{
int PicWidthInMbs = video->PicWidthInMbs;
// do frame-only and postpone intraAvail calculattion
video->mbAddrA = mbNum - 1;
video->mbAddrB = mbNum - PicWidthInMbs;
video->mbAddrC = mbNum - PicWidthInMbs + 1;
video->mbAddrD = mbNum - PicWidthInMbs - 1;
video->mbAvailA = video->mbAvailB = video->mbAvailC = video->mbAvailD = 0;
if (video->mb_x)
{
video->mbAvailA = (video->mblock[video->mbAddrA].slice_id == video->currMB->slice_id);
if (video->mb_y)
{
video->mbAvailD = (video->mblock[video->mbAddrD].slice_id == video->currMB->slice_id);
}
}
if (video->mb_y)
{
video->mbAvailB = (video->mblock[video->mbAddrB].slice_id == video->currMB->slice_id);
if (video->mb_x < (PicWidthInMbs - 1))
{
video->mbAvailC = (video->mblock[video->mbAddrC].slice_id == video->currMB->slice_id);
}
}
return ;
}
bool mb_is_available(AVCMacroblock *mblock, uint PicSizeInMbs, int mbAddr, int currMbAddr)
{
if (mbAddr < 0 || mbAddr >= (int)PicSizeInMbs)
{
return FALSE;
}
if (mblock[mbAddr].slice_id != mblock[currMbAddr].slice_id)
{
return FALSE;
}
return TRUE;
}
OSCL_EXPORT_REF int predict_nnz(AVCCommonObj *video, int i, int j)
{
int pred_nnz = 0;
int cnt = 1;
AVCMacroblock *tempMB;
/* left block */
/*getLuma4x4Neighbour(video, mb_nr, i, j, -1, 0, &pix);
leftMB = video->mblock + pix.mb_addr; */
/* replace the above with below (won't work for field decoding), 1/19/04 */
if (i)
{
pred_nnz = video->currMB->nz_coeff[(j<<2)+i-1];
}
else
{
if (video->mbAvailA)
{
tempMB = video->mblock + video->mbAddrA;
pred_nnz = tempMB->nz_coeff[(j<<2)+3];
}
else
{
cnt = 0;
}
}
/* top block */
/*getLuma4x4Neighbour(video, mb_nr, i, j, 0, -1, &pix);
topMB = video->mblock + pix.mb_addr;*/
/* replace the above with below (won't work for field decoding), 1/19/04 */
if (j)
{
pred_nnz += video->currMB->nz_coeff[((j-1)<<2)+i];
cnt++;
}
else
{
if (video->mbAvailB)
{
tempMB = video->mblock + video->mbAddrB;
pred_nnz += tempMB->nz_coeff[12+i];
cnt++;
}
}
if (cnt == 2)
{
pred_nnz = (pred_nnz + 1) >> 1;
}
return pred_nnz;
}
OSCL_EXPORT_REF int predict_nnz_chroma(AVCCommonObj *video, int i, int j)
{
int pred_nnz = 0;
int cnt = 1;
AVCMacroblock *tempMB;
/* left block */
/*getChroma4x4Neighbour(video, mb_nr, i%2, j-4, -1, 0, &pix);
leftMB = video->mblock + pix.mb_addr;*/
/* replace the above with below (won't work for field decoding), 1/19/04 */
if (i&1)
{
pred_nnz = video->currMB->nz_coeff[(j<<2)+i-1];
}
else
{
if (video->mbAvailA)
{
tempMB = video->mblock + video->mbAddrA;
pred_nnz = tempMB->nz_coeff[(j<<2)+i+1];
}
else
{
cnt = 0;
}
}
/* top block */
/*getChroma4x4Neighbour(video, mb_nr, i%2, j-4, 0, -1, &pix);
topMB = video->mblock + pix.mb_addr;*/
/* replace the above with below (won't work for field decoding), 1/19/04 */
if (j&1)
{
pred_nnz += video->currMB->nz_coeff[((j-1)<<2)+i];
cnt++;
}
else
{
if (video->mbAvailB)
{
tempMB = video->mblock + video->mbAddrB;
pred_nnz += tempMB->nz_coeff[20+i];
cnt++;
}
}
if (cnt == 2)
{
pred_nnz = (pred_nnz + 1) >> 1;
}
return pred_nnz;
}
OSCL_EXPORT_REF void GetMotionVectorPredictor(AVCCommonObj *video, int encFlag)
{
AVCMacroblock *currMB = video->currMB;
AVCMacroblock *MB_A, *MB_B, *MB_C, *MB_D;
int block_x, block_y, block_x_1, block_y_1, new_block_x;
int mbPartIdx, subMbPartIdx, offset_indx;
int16 *mv, pmv_x, pmv_y;
int nmSubMbHeight, nmSubMbWidth, mbPartIdx_X, mbPartIdx_Y;
int avail_a, avail_b, avail_c;
const static uint32 C = 0x5750;
int i, j, offset_MbPart_indx, refIdxLXA, refIdxLXB, refIdxLXC = 0, curr_ref_idx;
int pmv_A_x, pmv_B_x, pmv_C_x = 0, pmv_A_y, pmv_B_y, pmv_C_y = 0;
/* we have to take care of Intra/skip blocks somewhere, i.e. set MV to 0 and set ref to -1! */
/* we have to populate refIdx as well */
MB_A = &video->mblock[video->mbAddrA];
MB_B = &video->mblock[video->mbAddrB];
if (currMB->mbMode == AVC_SKIP /* && !encFlag */) /* only for decoder */
{
currMB->ref_idx_L0[0] = currMB->ref_idx_L0[1] = currMB->ref_idx_L0[2] = currMB->ref_idx_L0[3] = 0;
if (video->mbAvailA && video->mbAvailB)
{
if ((MB_A->ref_idx_L0[1] == 0 && MB_A->mvL0[3] == 0) ||
(MB_B->ref_idx_L0[2] == 0 && MB_B->mvL0[12] == 0))
{
memset(currMB->mvL0, 0, sizeof(int32)*16);
return;
}
}
else
{
memset(currMB->mvL0, 0, sizeof(int32)*16);
return;
}
video->mvd_l0[0][0][0] = 0;
video->mvd_l0[0][0][1] = 0;
}
MB_C = &video->mblock[video->mbAddrC];
MB_D = &video->mblock[video->mbAddrD];
offset_MbPart_indx = 0;
for (mbPartIdx = 0; mbPartIdx < currMB->NumMbPart; mbPartIdx++)
{
offset_indx = 0;
nmSubMbHeight = currMB->SubMbPartHeight[mbPartIdx] >> 2;
nmSubMbWidth = currMB->SubMbPartWidth[mbPartIdx] >> 2;
mbPartIdx_X = ((mbPartIdx + offset_MbPart_indx) & 1) << 1;
mbPartIdx_Y = (mbPartIdx + offset_MbPart_indx) & 2;
for (subMbPartIdx = 0; subMbPartIdx < currMB->NumSubMbPart[mbPartIdx]; subMbPartIdx++)
{
block_x = mbPartIdx_X + ((subMbPartIdx + offset_indx) & 1);
block_y = mbPartIdx_Y + (((subMbPartIdx + offset_indx) >> 1) & 1);
block_x_1 = block_x - 1;
block_y_1 = block_y - 1;
refIdxLXA = refIdxLXB = refIdxLXC = -1;
pmv_A_x = pmv_A_y = pmv_B_x = pmv_B_y = pmv_C_x = pmv_C_y = 0;
if (block_x)
{
avail_a = 1;
refIdxLXA = currMB->ref_idx_L0[(block_y & 2) + (block_x_1 >> 1)];
mv = (int16*)(currMB->mvL0 + (block_y << 2) + block_x_1);
pmv_A_x = *mv++;
pmv_A_y = *mv;
}
else
{
avail_a = video->mbAvailA;
if (avail_a)
{
refIdxLXA = MB_A->ref_idx_L0[(block_y & 2) + 1];
mv = (int16*)(MB_A->mvL0 + (block_y << 2) + 3);
pmv_A_x = *mv++;
pmv_A_y = *mv;
}
}
if (block_y)
{
avail_b = 1;
refIdxLXB = currMB->ref_idx_L0[(block_y_1 & 2) + (block_x >> 1)];
mv = (int16*)(currMB->mvL0 + (block_y_1 << 2) + block_x);
pmv_B_x = *mv++;
pmv_B_y = *mv;
}
else
{
avail_b = video->mbAvailB;
if (avail_b)
{
refIdxLXB = MB_B->ref_idx_L0[2 + (block_x >> 1)];
mv = (int16*)(MB_B->mvL0 + 12 + block_x);
pmv_B_x = *mv++;
pmv_B_y = *mv;
}
}
new_block_x = block_x + (currMB->SubMbPartWidth[mbPartIdx] >> 2) - 1;
avail_c = (C >> ((block_y << 2) + new_block_x)) & 0x1;
if (avail_c)
{
/* it guaranteed that block_y > 0 && new_block_x<3 ) */
refIdxLXC = currMB->ref_idx_L0[(block_y_1 & 2) + ((new_block_x+1) >> 1)];
mv = (int16*)(currMB->mvL0 + (block_y_1 << 2) + (new_block_x + 1));
pmv_C_x = *mv++;
pmv_C_y = *mv;
}
else
{
if (block_y == 0 && new_block_x < 3)
{
avail_c = video->mbAvailB;
if (avail_c)
{
refIdxLXC = MB_B->ref_idx_L0[2 + ((new_block_x+1)>>1)];
mv = (int16*)(MB_B->mvL0 + 12 + (new_block_x + 1));
pmv_C_x = *mv++;
pmv_C_y = *mv;
}
}
else if (block_y == 0 && new_block_x == 3)
{
avail_c = video->mbAvailC;
if (avail_c)
{
refIdxLXC = MB_C->ref_idx_L0[2];
mv = (int16*)(MB_C->mvL0 + 12);
pmv_C_x = *mv++;
pmv_C_y = *mv;
}
}
if (avail_c == 0)
{ /* check D */
if (block_x && block_y)
{
avail_c = 1;
refIdxLXC = currMB->ref_idx_L0[(block_y_1 & 2) + (block_x_1 >> 1)];
mv = (int16*)(currMB->mvL0 + (block_y_1 << 2) + block_x_1);
pmv_C_x = *mv++;
pmv_C_y = *mv;
}
else if (block_y)
{
avail_c = video->mbAvailA;
if (avail_c)
{
refIdxLXC = MB_A->ref_idx_L0[(block_y_1 & 2) + 1];
mv = (int16*)(MB_A->mvL0 + (block_y_1 << 2) + 3);
pmv_C_x = *mv++;
pmv_C_y = *mv;
}
}
else if (block_x)
{
avail_c = video->mbAvailB;
if (avail_c)
{
refIdxLXC = MB_B->ref_idx_L0[2 + (block_x_1 >> 1)];
mv = (int16*)(MB_B->mvL0 + 12 + block_x_1);
pmv_C_x = *mv++;
pmv_C_y = *mv;
}
}
else
{
avail_c = video->mbAvailD;
if (avail_c)
{
refIdxLXC = MB_D->ref_idx_L0[3];
mv = (int16*)(MB_D->mvL0 + 15);
pmv_C_x = *mv++;
pmv_C_y = *mv;
}
}
}
}
offset_indx = currMB->SubMbPartWidth[mbPartIdx] >> 3;
curr_ref_idx = currMB->ref_idx_L0[(block_y & 2) + (block_x >> 1)];
if (avail_a && !(avail_b || avail_c))
{
pmv_x = pmv_A_x;
pmv_y = pmv_A_y;
}
else if (((curr_ref_idx == refIdxLXA) + (curr_ref_idx == refIdxLXB) + (curr_ref_idx == refIdxLXC)) == 1)
{
if (curr_ref_idx == refIdxLXA)
{
pmv_x = pmv_A_x;
pmv_y = pmv_A_y;
}
else if (curr_ref_idx == refIdxLXB)
{
pmv_x = pmv_B_x;
pmv_y = pmv_B_y;
}
else
{
pmv_x = pmv_C_x;
pmv_y = pmv_C_y;
}
}
else
{
pmv_x = AVC_MEDIAN(pmv_A_x, pmv_B_x, pmv_C_x);
pmv_y = AVC_MEDIAN(pmv_A_y, pmv_B_y, pmv_C_y);
}
/* overwrite if special case */
if (currMB->NumMbPart == 2)
{
if (currMB->MbPartWidth == 16)
{
if (mbPartIdx == 0)
{
if (refIdxLXB == curr_ref_idx)
{
pmv_x = pmv_B_x;
pmv_y = pmv_B_y;
}
}
else if (refIdxLXA == curr_ref_idx)
{
pmv_x = pmv_A_x;
pmv_y = pmv_A_y;
}
}
else
{
if (mbPartIdx == 0)
{
if (refIdxLXA == curr_ref_idx)
{
pmv_x = pmv_A_x;
pmv_y = pmv_A_y;
}
}
else if (refIdxLXC == curr_ref_idx)
{
pmv_x = pmv_C_x;
pmv_y = pmv_C_y;
}
}
}
mv = (int16*)(currMB->mvL0 + block_x + (block_y << 2));
if (encFlag) /* calculate residual MV video->mvd_l0 */
{
video->mvd_l0[mbPartIdx][subMbPartIdx][0] = *mv++ - pmv_x;
video->mvd_l0[mbPartIdx][subMbPartIdx][1] = *mv++ - pmv_y;
}
else /* calculate original MV currMB->mvL0 */
{
pmv_x += video->mvd_l0[mbPartIdx][subMbPartIdx][0];
pmv_y += video->mvd_l0[mbPartIdx][subMbPartIdx][1];
for (i = 0; i < nmSubMbHeight; i++)
{
for (j = 0; j < nmSubMbWidth; j++)
{
*mv++ = pmv_x;
*mv++ = pmv_y;
}
mv += (8 - (j << 1));
}
}
}
offset_MbPart_indx = currMB->MbPartWidth >> 4;
}
}
Jump to Line
Something went wrong with that request. Please try again.