| /* |
| * Copyright (C) 2009 The Android Open Source Project |
| * |
| * 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. |
| */ |
| |
| /*------------------------------------------------------------------------------ |
| |
| Table of contents |
| |
| 1. Include headers |
| 2. External compiler flags |
| 3. Module defines |
| 4. Local function prototypes |
| 5. Functions |
| ComparePictures |
| h264bsdReorderRefPicList |
| Mmcop1 |
| Mmcop2 |
| Mmcop3 |
| Mmcop4 |
| Mmcop5 |
| Mmcop6 |
| h264bsdMarkDecRefPic |
| h264bsdGetRefPicData |
| h264bsdAllocateDpbImage |
| SlidingWindowRefPicMarking |
| h264bsdInitDpb |
| h264bsdResetDpb |
| h264bsdInitRefPicList |
| FindDpbPic |
| SetPicNums |
| h264bsdCheckGapsInFrameNum |
| FindSmallestPicOrderCnt |
| OutputPicture |
| h264bsdDpbOutputPicture |
| h264bsdFlushDpb |
| h264bsdFreeDpb |
| |
| ------------------------------------------------------------------------------*/ |
| |
| /*------------------------------------------------------------------------------ |
| 1. Include headers |
| ------------------------------------------------------------------------------*/ |
| |
| #include "h264bsd_cfg.h" |
| #include "h264bsd_dpb.h" |
| #include "h264bsd_slice_header.h" |
| #include "h264bsd_image.h" |
| #include "h264bsd_util.h" |
| #include "basetype.h" |
| |
| /*------------------------------------------------------------------------------ |
| 2. External compiler flags |
| -------------------------------------------------------------------------------- |
| |
| -------------------------------------------------------------------------------- |
| 3. Module defines |
| ------------------------------------------------------------------------------*/ |
| |
| /* macros to determine picture status. Note that IS_SHORT_TERM macro returns |
| * true also for non-existing pictures because non-existing pictures are |
| * regarded short term pictures according to H.264 standard */ |
| #define IS_REFERENCE(a) ((a).status) |
| #define IS_EXISTING(a) ((a).status > NON_EXISTING) |
| #define IS_SHORT_TERM(a) \ |
| ((a).status == NON_EXISTING || (a).status == SHORT_TERM) |
| #define IS_LONG_TERM(a) ((a).status == LONG_TERM) |
| |
| /* macro to set a picture unused for reference */ |
| #define SET_UNUSED(a) (a).status = UNUSED; |
| |
| #define MAX_NUM_REF_IDX_L0_ACTIVE 16 |
| |
| /*------------------------------------------------------------------------------ |
| 4. Local function prototypes |
| ------------------------------------------------------------------------------*/ |
| |
| static i32 ComparePictures(const void *ptr1, const void *ptr2); |
| |
| static u32 Mmcop1(dpbStorage_t *dpb, u32 currPicNum, u32 differenceOfPicNums); |
| |
| static u32 Mmcop2(dpbStorage_t *dpb, u32 longTermPicNum); |
| |
| static u32 Mmcop3(dpbStorage_t *dpb, u32 currPicNum, u32 differenceOfPicNums, |
| u32 longTermFrameIdx); |
| |
| static u32 Mmcop4(dpbStorage_t *dpb, u32 maxLongTermFrameIdx); |
| |
| static u32 Mmcop5(dpbStorage_t *dpb); |
| |
| static u32 Mmcop6(dpbStorage_t *dpb, u32 frameNum, i32 picOrderCnt, |
| u32 longTermFrameIdx); |
| |
| static u32 SlidingWindowRefPicMarking(dpbStorage_t *dpb); |
| |
| static i32 FindDpbPic(dpbStorage_t *dpb, i32 picNum, u32 isShortTerm); |
| |
| static void SetPicNums(dpbStorage_t *dpb, u32 currFrameNum); |
| |
| static dpbPicture_t* FindSmallestPicOrderCnt(dpbStorage_t *dpb); |
| |
| static u32 OutputPicture(dpbStorage_t *dpb); |
| |
| static void ShellSort(dpbPicture_t *pPic, u32 num); |
| |
| /*------------------------------------------------------------------------------ |
| |
| Function: ComparePictures |
| |
| Functional description: |
| Function to compare dpb pictures, used by the ShellSort() function. |
| Order of the pictures after sorting shall be as follows: |
| 1) short term reference pictures starting with the largest |
| picNum |
| 2) long term reference pictures starting with the smallest |
| longTermPicNum |
| 3) pictures unused for reference but needed for display |
| 4) other pictures |
| |
| Returns: |
| -1 pic 1 is greater than pic 2 |
| 0 equal from comparison point of view |
| 1 pic 2 is greater then pic 1 |
| |
| ------------------------------------------------------------------------------*/ |
| |
| static i32 ComparePictures(const void *ptr1, const void *ptr2) |
| { |
| |
| /* Variables */ |
| |
| dpbPicture_t *pic1, *pic2; |
| |
| /* Code */ |
| |
| ASSERT(ptr1); |
| ASSERT(ptr2); |
| |
| pic1 = (dpbPicture_t*)ptr1; |
| pic2 = (dpbPicture_t*)ptr2; |
| |
| /* both are non-reference pictures, check if needed for display */ |
| if (!IS_REFERENCE(*pic1) && !IS_REFERENCE(*pic2)) |
| { |
| if (pic1->toBeDisplayed && !pic2->toBeDisplayed) |
| return(-1); |
| else if (!pic1->toBeDisplayed && pic2->toBeDisplayed) |
| return(1); |
| else |
| return(0); |
| } |
| /* only pic 1 needed for reference -> greater */ |
| else if (!IS_REFERENCE(*pic2)) |
| return(-1); |
| /* only pic 2 needed for reference -> greater */ |
| else if (!IS_REFERENCE(*pic1)) |
| return(1); |
| /* both are short term reference pictures -> check picNum */ |
| else if (IS_SHORT_TERM(*pic1) && IS_SHORT_TERM(*pic2)) |
| { |
| if (pic1->picNum > pic2->picNum) |
| return(-1); |
| else if (pic1->picNum < pic2->picNum) |
| return(1); |
| else |
| return(0); |
| } |
| /* only pic 1 is short term -> greater */ |
| else if (IS_SHORT_TERM(*pic1)) |
| return(-1); |
| /* only pic 2 is short term -> greater */ |
| else if (IS_SHORT_TERM(*pic2)) |
| return(1); |
| /* both are long term reference pictures -> check picNum (contains the |
| * longTermPicNum */ |
| else |
| { |
| if (pic1->picNum > pic2->picNum) |
| return(1); |
| else if (pic1->picNum < pic2->picNum) |
| return(-1); |
| else |
| return(0); |
| } |
| } |
| |
| /*------------------------------------------------------------------------------ |
| |
| Function: h264bsdReorderRefPicList |
| |
| Functional description: |
| Function to perform reference picture list reordering based on |
| reordering commands received in the slice header. See details |
| of the process in the H.264 standard. |
| |
| Inputs: |
| dpb pointer to dpb storage structure |
| order pointer to reordering commands |
| currFrameNum current frame number |
| numRefIdxActive number of active reference indices for current |
| picture |
| |
| Outputs: |
| dpb 'list' field of the structure reordered |
| |
| Returns: |
| HANTRO_OK success |
| HANTRO_NOK if non-existing pictures referred to in the |
| reordering commands |
| |
| ------------------------------------------------------------------------------*/ |
| |
| u32 h264bsdReorderRefPicList( |
| dpbStorage_t *dpb, |
| refPicListReordering_t *order, |
| u32 currFrameNum, |
| u32 numRefIdxActive) |
| { |
| |
| /* Variables */ |
| |
| u32 i, j, k, picNumPred, refIdx; |
| i32 picNum, picNumNoWrap, index; |
| u32 isShortTerm; |
| |
| /* Code */ |
| |
| ASSERT(order); |
| ASSERT(currFrameNum <= dpb->maxFrameNum); |
| ASSERT(numRefIdxActive <= MAX_NUM_REF_IDX_L0_ACTIVE); |
| |
| /* set dpb picture numbers for sorting */ |
| SetPicNums(dpb, currFrameNum); |
| |
| if (!order->refPicListReorderingFlagL0) |
| return(HANTRO_OK); |
| |
| refIdx = 0; |
| picNumPred = currFrameNum; |
| |
| i = 0; |
| while (order->command[i].reorderingOfPicNumsIdc < 3) |
| { |
| /* short term */ |
| if (order->command[i].reorderingOfPicNumsIdc < 2) |
| { |
| if (order->command[i].reorderingOfPicNumsIdc == 0) |
| { |
| picNumNoWrap = |
| (i32)picNumPred - (i32)order->command[i].absDiffPicNum; |
| if (picNumNoWrap < 0) |
| picNumNoWrap += (i32)dpb->maxFrameNum; |
| } |
| else |
| { |
| picNumNoWrap = |
| (i32)(picNumPred + order->command[i].absDiffPicNum); |
| if (picNumNoWrap >= (i32)dpb->maxFrameNum) |
| picNumNoWrap -= (i32)dpb->maxFrameNum; |
| } |
| picNumPred = (u32)picNumNoWrap; |
| picNum = picNumNoWrap; |
| if ((u32)picNumNoWrap > currFrameNum) |
| picNum -= (i32)dpb->maxFrameNum; |
| isShortTerm = HANTRO_TRUE; |
| } |
| /* long term */ |
| else |
| { |
| picNum = (i32)order->command[i].longTermPicNum; |
| isShortTerm = HANTRO_FALSE; |
| |
| } |
| /* find corresponding picture from dpb */ |
| index = FindDpbPic(dpb, picNum, isShortTerm); |
| if (index < 0 || !IS_EXISTING(dpb->buffer[index])) |
| return(HANTRO_NOK); |
| |
| /* shift pictures */ |
| for (j = numRefIdxActive; j > refIdx; j--) |
| dpb->list[j] = dpb->list[j-1]; |
| /* put picture into the list */ |
| dpb->list[refIdx++] = &dpb->buffer[index]; |
| /* remove later references to the same picture */ |
| for (j = k = refIdx; j <= numRefIdxActive; j++) |
| if(dpb->list[j] != &dpb->buffer[index]) |
| dpb->list[k++] = dpb->list[j]; |
| |
| i++; |
| } |
| |
| return(HANTRO_OK); |
| |
| } |
| |
| /*------------------------------------------------------------------------------ |
| |
| Function: Mmcop1 |
| |
| Functional description: |
| Function to mark a short-term reference picture unused for |
| reference, memory_management_control_operation equal to 1 |
| |
| Returns: |
| HANTRO_OK success |
| HANTRO_NOK failure, picture does not exist in the buffer |
| |
| ------------------------------------------------------------------------------*/ |
| |
| static u32 Mmcop1(dpbStorage_t *dpb, u32 currPicNum, u32 differenceOfPicNums) |
| { |
| |
| /* Variables */ |
| |
| i32 index, picNum; |
| |
| /* Code */ |
| |
| ASSERT(currPicNum < dpb->maxFrameNum); |
| |
| picNum = (i32)currPicNum - (i32)differenceOfPicNums; |
| |
| index = FindDpbPic(dpb, picNum, HANTRO_TRUE); |
| if (index < 0) |
| return(HANTRO_NOK); |
| |
| SET_UNUSED(dpb->buffer[index]); |
| dpb->numRefFrames--; |
| if (!dpb->buffer[index].toBeDisplayed) |
| dpb->fullness--; |
| |
| return(HANTRO_OK); |
| |
| } |
| |
| /*------------------------------------------------------------------------------ |
| |
| Function: Mmcop2 |
| |
| Functional description: |
| Function to mark a long-term reference picture unused for |
| reference, memory_management_control_operation equal to 2 |
| |
| Returns: |
| HANTRO_OK success |
| HANTRO_NOK failure, picture does not exist in the buffer |
| |
| ------------------------------------------------------------------------------*/ |
| |
| static u32 Mmcop2(dpbStorage_t *dpb, u32 longTermPicNum) |
| { |
| |
| /* Variables */ |
| |
| i32 index; |
| |
| /* Code */ |
| |
| index = FindDpbPic(dpb, (i32)longTermPicNum, HANTRO_FALSE); |
| if (index < 0) |
| return(HANTRO_NOK); |
| |
| SET_UNUSED(dpb->buffer[index]); |
| dpb->numRefFrames--; |
| if (!dpb->buffer[index].toBeDisplayed) |
| dpb->fullness--; |
| |
| return(HANTRO_OK); |
| |
| } |
| |
| /*------------------------------------------------------------------------------ |
| |
| Function: Mmcop3 |
| |
| Functional description: |
| Function to assing a longTermFrameIdx to a short-term reference |
| frame (i.e. to change it to a long-term reference picture), |
| memory_management_control_operation equal to 3 |
| |
| Returns: |
| HANTRO_OK success |
| HANTRO_NOK failure, short-term picture does not exist in the |
| buffer or is a non-existing picture, or invalid |
| longTermFrameIdx given |
| |
| ------------------------------------------------------------------------------*/ |
| |
| static u32 Mmcop3(dpbStorage_t *dpb, u32 currPicNum, u32 differenceOfPicNums, |
| u32 longTermFrameIdx) |
| { |
| |
| /* Variables */ |
| |
| i32 index, picNum; |
| u32 i; |
| |
| /* Code */ |
| |
| ASSERT(dpb); |
| ASSERT(currPicNum < dpb->maxFrameNum); |
| |
| if ( (dpb->maxLongTermFrameIdx == NO_LONG_TERM_FRAME_INDICES) || |
| (longTermFrameIdx > dpb->maxLongTermFrameIdx) ) |
| return(HANTRO_NOK); |
| |
| /* check if a long term picture with the same longTermFrameIdx already |
| * exist and remove it if necessary */ |
| for (i = 0; i < dpb->maxRefFrames; i++) |
| if (IS_LONG_TERM(dpb->buffer[i]) && |
| (u32)dpb->buffer[i].picNum == longTermFrameIdx) |
| { |
| SET_UNUSED(dpb->buffer[i]); |
| dpb->numRefFrames--; |
| if (!dpb->buffer[i].toBeDisplayed) |
| dpb->fullness--; |
| break; |
| } |
| |
| picNum = (i32)currPicNum - (i32)differenceOfPicNums; |
| |
| index = FindDpbPic(dpb, picNum, HANTRO_TRUE); |
| if (index < 0) |
| return(HANTRO_NOK); |
| if (!IS_EXISTING(dpb->buffer[index])) |
| return(HANTRO_NOK); |
| |
| dpb->buffer[index].status = LONG_TERM; |
| dpb->buffer[index].picNum = (i32)longTermFrameIdx; |
| |
| return(HANTRO_OK); |
| |
| } |
| |
| /*------------------------------------------------------------------------------ |
| |
| Function: Mmcop4 |
| |
| Functional description: |
| Function to set maxLongTermFrameIdx, |
| memory_management_control_operation equal to 4 |
| |
| Returns: |
| HANTRO_OK success |
| |
| ------------------------------------------------------------------------------*/ |
| |
| static u32 Mmcop4(dpbStorage_t *dpb, u32 maxLongTermFrameIdx) |
| { |
| |
| /* Variables */ |
| |
| u32 i; |
| |
| /* Code */ |
| |
| dpb->maxLongTermFrameIdx = maxLongTermFrameIdx; |
| |
| for (i = 0; i < dpb->maxRefFrames; i++) |
| if (IS_LONG_TERM(dpb->buffer[i]) && |
| ( ((u32)dpb->buffer[i].picNum > maxLongTermFrameIdx) || |
| (dpb->maxLongTermFrameIdx == NO_LONG_TERM_FRAME_INDICES) ) ) |
| { |
| SET_UNUSED(dpb->buffer[i]); |
| dpb->numRefFrames--; |
| if (!dpb->buffer[i].toBeDisplayed) |
| dpb->fullness--; |
| } |
| |
| return(HANTRO_OK); |
| |
| } |
| |
| /*------------------------------------------------------------------------------ |
| |
| Function: Mmcop5 |
| |
| Functional description: |
| Function to mark all reference pictures unused for reference and |
| set maxLongTermFrameIdx to NO_LONG_TERM_FRAME_INDICES, |
| memory_management_control_operation equal to 5. Function flushes |
| the buffer and places all pictures that are needed for display into |
| the output buffer. |
| |
| Returns: |
| HANTRO_OK success |
| |
| ------------------------------------------------------------------------------*/ |
| |
| static u32 Mmcop5(dpbStorage_t *dpb) |
| { |
| |
| /* Variables */ |
| |
| u32 i; |
| |
| /* Code */ |
| |
| for (i = 0; i < 16; i++) |
| { |
| if (IS_REFERENCE(dpb->buffer[i])) |
| { |
| SET_UNUSED(dpb->buffer[i]); |
| if (!dpb->buffer[i].toBeDisplayed) |
| dpb->fullness--; |
| } |
| } |
| |
| /* output all pictures */ |
| while (OutputPicture(dpb) == HANTRO_OK) |
| ; |
| dpb->numRefFrames = 0; |
| dpb->maxLongTermFrameIdx = NO_LONG_TERM_FRAME_INDICES; |
| dpb->prevRefFrameNum = 0; |
| |
| return(HANTRO_OK); |
| |
| } |
| |
| /*------------------------------------------------------------------------------ |
| |
| Function: Mmcop6 |
| |
| Functional description: |
| Function to assign longTermFrameIdx to the current picture, |
| memory_management_control_operation equal to 6 |
| |
| Returns: |
| HANTRO_OK success |
| HANTRO_NOK invalid longTermFrameIdx or no room for current |
| picture in the buffer |
| |
| ------------------------------------------------------------------------------*/ |
| |
| static u32 Mmcop6(dpbStorage_t *dpb, u32 frameNum, i32 picOrderCnt, |
| u32 longTermFrameIdx) |
| { |
| |
| /* Variables */ |
| |
| u32 i; |
| |
| /* Code */ |
| |
| ASSERT(frameNum < dpb->maxFrameNum); |
| |
| if ( (dpb->maxLongTermFrameIdx == NO_LONG_TERM_FRAME_INDICES) || |
| (longTermFrameIdx > dpb->maxLongTermFrameIdx) ) |
| return(HANTRO_NOK); |
| |
| /* check if a long term picture with the same longTermFrameIdx already |
| * exist and remove it if necessary */ |
| for (i = 0; i < dpb->maxRefFrames; i++) |
| if (IS_LONG_TERM(dpb->buffer[i]) && |
| (u32)dpb->buffer[i].picNum == longTermFrameIdx) |
| { |
| SET_UNUSED(dpb->buffer[i]); |
| dpb->numRefFrames--; |
| if (!dpb->buffer[i].toBeDisplayed) |
| dpb->fullness--; |
| break; |
| } |
| |
| if (dpb->numRefFrames < dpb->maxRefFrames) |
| { |
| dpb->currentOut->frameNum = frameNum; |
| dpb->currentOut->picNum = (i32)longTermFrameIdx; |
| dpb->currentOut->picOrderCnt = picOrderCnt; |
| dpb->currentOut->status = LONG_TERM; |
| if (dpb->noReordering) |
| dpb->currentOut->toBeDisplayed = HANTRO_FALSE; |
| else |
| dpb->currentOut->toBeDisplayed = HANTRO_TRUE; |
| dpb->numRefFrames++; |
| dpb->fullness++; |
| return(HANTRO_OK); |
| } |
| /* if there is no room, return an error */ |
| else |
| return(HANTRO_NOK); |
| |
| } |
| |
| /*------------------------------------------------------------------------------ |
| |
| Function: h264bsdMarkDecRefPic |
| |
| Functional description: |
| Function to perform reference picture marking process. This |
| function should be called both for reference and non-reference |
| pictures. Non-reference pictures shall have mark pointer set to |
| NULL. |
| |
| Inputs: |
| dpb pointer to the DPB data structure |
| mark pointer to reference picture marking commands |
| image pointer to current picture to be placed in the buffer |
| frameNum frame number of the current picture |
| picOrderCnt picture order count for the current picture |
| isIdr flag to indicate if the current picture is an |
| IDR picture |
| currentPicId identifier for the current picture, from the |
| application, stored along with the picture |
| numErrMbs number of concealed macroblocks in the current |
| picture, stored along with the picture |
| |
| Outputs: |
| dpb 'buffer' modified, possible output frames placed into |
| 'outBuf' |
| |
| Returns: |
| HANTRO_OK success |
| HANTRO_NOK failure |
| |
| ------------------------------------------------------------------------------*/ |
| |
| u32 h264bsdMarkDecRefPic( |
| dpbStorage_t *dpb, |
| decRefPicMarking_t *mark, |
| image_t *image, |
| u32 frameNum, |
| i32 picOrderCnt, |
| u32 isIdr, |
| u32 currentPicId, |
| u32 numErrMbs) |
| { |
| |
| /* Variables */ |
| |
| u32 i, status; |
| u32 markedAsLongTerm; |
| u32 toBeDisplayed; |
| |
| /* Code */ |
| |
| ASSERT(dpb); |
| ASSERT(mark || !isIdr); |
| ASSERT(!isIdr || (frameNum == 0 && picOrderCnt == 0)); |
| ASSERT(frameNum < dpb->maxFrameNum); |
| |
| if (image->data != dpb->currentOut->data) |
| { |
| EPRINT("TRYING TO MARK NON-ALLOCATED IMAGE"); |
| return(HANTRO_NOK); |
| } |
| |
| dpb->lastContainsMmco5 = HANTRO_FALSE; |
| status = HANTRO_OK; |
| |
| toBeDisplayed = dpb->noReordering ? HANTRO_FALSE : HANTRO_TRUE; |
| |
| /* non-reference picture, stored for display reordering purposes */ |
| if (mark == NULL) |
| { |
| dpb->currentOut->status = UNUSED; |
| dpb->currentOut->frameNum = frameNum; |
| dpb->currentOut->picNum = (i32)frameNum; |
| dpb->currentOut->picOrderCnt = picOrderCnt; |
| dpb->currentOut->toBeDisplayed = toBeDisplayed; |
| if (!dpb->noReordering) |
| dpb->fullness++; |
| } |
| /* IDR picture */ |
| else if (isIdr) |
| { |
| |
| /* h264bsdCheckGapsInFrameNum not called for IDR pictures -> have to |
| * reset numOut and outIndex here */ |
| dpb->numOut = dpb->outIndex = 0; |
| |
| /* flush the buffer */ |
| Mmcop5(dpb); |
| /* if noOutputOfPriorPicsFlag was set -> the pictures preceding the |
| * IDR picture shall not be output -> set output buffer empty */ |
| if (mark->noOutputOfPriorPicsFlag || dpb->noReordering) |
| { |
| dpb->numOut = 0; |
| dpb->outIndex = 0; |
| } |
| |
| if (mark->longTermReferenceFlag) |
| { |
| dpb->currentOut->status = LONG_TERM; |
| dpb->maxLongTermFrameIdx = 0; |
| } |
| else |
| { |
| dpb->currentOut->status = SHORT_TERM; |
| dpb->maxLongTermFrameIdx = NO_LONG_TERM_FRAME_INDICES; |
| } |
| dpb->currentOut->frameNum = 0; |
| dpb->currentOut->picNum = 0; |
| dpb->currentOut->picOrderCnt = 0; |
| dpb->currentOut->toBeDisplayed = toBeDisplayed; |
| dpb->fullness = 1; |
| dpb->numRefFrames = 1; |
| } |
| /* reference picture */ |
| else |
| { |
| markedAsLongTerm = HANTRO_FALSE; |
| if (mark->adaptiveRefPicMarkingModeFlag) |
| { |
| i = 0; |
| while (mark->operation[i].memoryManagementControlOperation) |
| { |
| switch (mark->operation[i].memoryManagementControlOperation) |
| { |
| case 1: |
| status = Mmcop1( |
| dpb, |
| frameNum, |
| mark->operation[i].differenceOfPicNums); |
| break; |
| |
| case 2: |
| status = Mmcop2(dpb, mark->operation[i].longTermPicNum); |
| break; |
| |
| case 3: |
| status = Mmcop3( |
| dpb, |
| frameNum, |
| mark->operation[i].differenceOfPicNums, |
| mark->operation[i].longTermFrameIdx); |
| break; |
| |
| case 4: |
| status = Mmcop4( |
| dpb, |
| mark->operation[i].maxLongTermFrameIdx); |
| break; |
| |
| case 5: |
| status = Mmcop5(dpb); |
| dpb->lastContainsMmco5 = HANTRO_TRUE; |
| frameNum = 0; |
| break; |
| |
| case 6: |
| status = Mmcop6( |
| dpb, |
| frameNum, |
| picOrderCnt, |
| mark->operation[i].longTermFrameIdx); |
| if (status == HANTRO_OK) |
| markedAsLongTerm = HANTRO_TRUE; |
| break; |
| |
| default: /* invalid memory management control operation */ |
| status = HANTRO_NOK; |
| break; |
| } |
| if (status != HANTRO_OK) |
| { |
| break; |
| } |
| i++; |
| } |
| } |
| else |
| { |
| status = SlidingWindowRefPicMarking(dpb); |
| } |
| /* if current picture was not marked as long-term reference by |
| * memory management control operation 6 -> mark current as short |
| * term and insert it into dpb (if there is room) */ |
| if (!markedAsLongTerm) |
| { |
| if (dpb->numRefFrames < dpb->maxRefFrames) |
| { |
| dpb->currentOut->frameNum = frameNum; |
| dpb->currentOut->picNum = (i32)frameNum; |
| dpb->currentOut->picOrderCnt = picOrderCnt; |
| dpb->currentOut->status = SHORT_TERM; |
| dpb->currentOut->toBeDisplayed = toBeDisplayed; |
| dpb->fullness++; |
| dpb->numRefFrames++; |
| } |
| /* no room */ |
| else |
| { |
| status = HANTRO_NOK; |
| } |
| } |
| } |
| |
| dpb->currentOut->isIdr = isIdr; |
| dpb->currentOut->picId = currentPicId; |
| dpb->currentOut->numErrMbs = numErrMbs; |
| |
| /* dpb was initialized to not to reorder the pictures -> output current |
| * picture immediately */ |
| if (dpb->noReordering) |
| { |
| ASSERT(dpb->numOut == 0); |
| ASSERT(dpb->outIndex == 0); |
| dpb->outBuf[dpb->numOut].data = dpb->currentOut->data; |
| dpb->outBuf[dpb->numOut].isIdr = dpb->currentOut->isIdr; |
| dpb->outBuf[dpb->numOut].picId = dpb->currentOut->picId; |
| dpb->outBuf[dpb->numOut].numErrMbs = dpb->currentOut->numErrMbs; |
| dpb->numOut++; |
| } |
| else |
| { |
| /* output pictures if buffer full */ |
| while (dpb->fullness > dpb->dpbSize) |
| { |
| i = OutputPicture(dpb); |
| ASSERT(i == HANTRO_OK); |
| } |
| } |
| |
| /* sort dpb */ |
| ShellSort(dpb->buffer, dpb->dpbSize+1); |
| |
| return(status); |
| |
| } |
| |
| /*------------------------------------------------------------------------------ |
| |
| Function: h264bsdGetRefPicData |
| |
| Functional description: |
| Function to get reference picture data from the reference picture |
| list |
| |
| Returns: |
| pointer to desired reference picture data |
| NULL if invalid index or non-existing picture referred |
| |
| ------------------------------------------------------------------------------*/ |
| |
| u8* h264bsdGetRefPicData(dpbStorage_t *dpb, u32 index) |
| { |
| |
| /* Variables */ |
| |
| /* Code */ |
| |
| if(index > 16 || dpb->list[index] == NULL) |
| return(NULL); |
| else if(!IS_EXISTING(*dpb->list[index])) |
| return(NULL); |
| else |
| return(dpb->list[index]->data); |
| |
| } |
| |
| /*------------------------------------------------------------------------------ |
| |
| Function: h264bsdAllocateDpbImage |
| |
| Functional description: |
| function to allocate memory for a image. This function does not |
| really allocate any memory but reserves one of the buffer |
| positions for decoding of current picture |
| |
| Returns: |
| pointer to memory area for the image |
| |
| |
| ------------------------------------------------------------------------------*/ |
| |
| u8* h264bsdAllocateDpbImage(dpbStorage_t *dpb) |
| { |
| |
| /* Variables */ |
| |
| /* Code */ |
| |
| ASSERT( !dpb->buffer[dpb->dpbSize].toBeDisplayed && |
| !IS_REFERENCE(dpb->buffer[dpb->dpbSize]) ); |
| ASSERT(dpb->fullness <= dpb->dpbSize); |
| |
| dpb->currentOut = dpb->buffer + dpb->dpbSize; |
| |
| return(dpb->currentOut->data); |
| |
| } |
| |
| /*------------------------------------------------------------------------------ |
| |
| Function: SlidingWindowRefPicMarking |
| |
| Functional description: |
| Function to perform sliding window refence picture marking process. |
| |
| Outputs: |
| HANTRO_OK success |
| HANTRO_NOK failure, no short-term reference frame found that |
| could be marked unused |
| |
| |
| ------------------------------------------------------------------------------*/ |
| |
| static u32 SlidingWindowRefPicMarking(dpbStorage_t *dpb) |
| { |
| |
| /* Variables */ |
| |
| i32 index, picNum; |
| u32 i; |
| |
| /* Code */ |
| |
| if (dpb->numRefFrames < dpb->maxRefFrames) |
| { |
| return(HANTRO_OK); |
| } |
| else |
| { |
| index = -1; |
| picNum = 0; |
| /* find the oldest short term picture */ |
| for (i = 0; i < dpb->numRefFrames; i++) |
| if (IS_SHORT_TERM(dpb->buffer[i])) |
| if (dpb->buffer[i].picNum < picNum || index == -1) |
| { |
| index = (i32)i; |
| picNum = dpb->buffer[i].picNum; |
| } |
| if (index >= 0) |
| { |
| SET_UNUSED(dpb->buffer[index]); |
| dpb->numRefFrames--; |
| if (!dpb->buffer[index].toBeDisplayed) |
| dpb->fullness--; |
| |
| return(HANTRO_OK); |
| } |
| } |
| |
| return(HANTRO_NOK); |
| |
| } |
| |
| /*------------------------------------------------------------------------------ |
| |
| Function: h264bsdInitDpb |
| |
| Functional description: |
| Function to initialize DPB. Reserves memories for the buffer, |
| reference picture list and output buffer. dpbSize indicates |
| the maximum DPB size indicated by the levelIdc in the stream. |
| If noReordering flag is FALSE the DPB stores dpbSize pictures |
| for display reordering purposes. On the other hand, if the |
| flag is TRUE the DPB only stores maxRefFrames reference pictures |
| and outputs all the pictures immediately. |
| |
| Inputs: |
| picSizeInMbs picture size in macroblocks |
| dpbSize size of the DPB (number of pictures) |
| maxRefFrames max number of reference frames |
| maxFrameNum max frame number |
| noReordering flag to indicate that DPB does not have to |
| prepare to reorder frames for display |
| |
| Outputs: |
| dpb pointer to dpb data storage |
| |
| Returns: |
| HANTRO_OK success |
| MEMORY_ALLOCATION_ERROR if memory allocation failed |
| |
| ------------------------------------------------------------------------------*/ |
| |
| u32 h264bsdInitDpb( |
| dpbStorage_t *dpb, |
| u32 picSizeInMbs, |
| u32 dpbSize, |
| u32 maxRefFrames, |
| u32 maxFrameNum, |
| u32 noReordering) |
| { |
| |
| /* Variables */ |
| |
| u32 i; |
| |
| /* Code */ |
| |
| ASSERT(picSizeInMbs); |
| ASSERT(maxRefFrames <= MAX_NUM_REF_PICS); |
| ASSERT(maxRefFrames <= dpbSize); |
| ASSERT(maxFrameNum); |
| ASSERT(dpbSize); |
| |
| dpb->maxLongTermFrameIdx = NO_LONG_TERM_FRAME_INDICES; |
| dpb->maxRefFrames = MAX(maxRefFrames, 1); |
| if (noReordering) |
| dpb->dpbSize = dpb->maxRefFrames; |
| else |
| dpb->dpbSize = dpbSize; |
| dpb->maxFrameNum = maxFrameNum; |
| dpb->noReordering = noReordering; |
| dpb->fullness = 0; |
| dpb->numRefFrames = 0; |
| dpb->prevRefFrameNum = 0; |
| |
| ALLOCATE(dpb->buffer, MAX_NUM_REF_IDX_L0_ACTIVE + 1, dpbPicture_t); |
| if (dpb->buffer == NULL) |
| return(MEMORY_ALLOCATION_ERROR); |
| H264SwDecMemset(dpb->buffer, 0, |
| (MAX_NUM_REF_IDX_L0_ACTIVE + 1)*sizeof(dpbPicture_t)); |
| for (i = 0; i < dpb->dpbSize + 1; i++) |
| { |
| /* Allocate needed amount of memory, which is: |
| * image size + 32 + 15, where 32 cames from the fact that in ARM OpenMax |
| * DL implementation Functions may read beyond the end of an array, |
| * by a maximum of 32 bytes. And +15 cames for the need to align memory |
| * to 16-byte boundary */ |
| ALLOCATE(dpb->buffer[i].pAllocatedData, (picSizeInMbs*384 + 32+15), u8); |
| if (dpb->buffer[i].pAllocatedData == NULL) |
| return(MEMORY_ALLOCATION_ERROR); |
| |
| dpb->buffer[i].data = ALIGN(dpb->buffer[i].pAllocatedData, 16); |
| } |
| |
| ALLOCATE(dpb->list, MAX_NUM_REF_IDX_L0_ACTIVE + 1, dpbPicture_t*); |
| ALLOCATE(dpb->outBuf, dpb->dpbSize+1, dpbOutPicture_t); |
| |
| if (dpb->list == NULL || dpb->outBuf == NULL) |
| return(MEMORY_ALLOCATION_ERROR); |
| |
| H264SwDecMemset(dpb->list, 0, |
| ((MAX_NUM_REF_IDX_L0_ACTIVE + 1) * sizeof(dpbPicture_t*)) ); |
| |
| dpb->numOut = dpb->outIndex = 0; |
| |
| return(HANTRO_OK); |
| |
| } |
| |
| /*------------------------------------------------------------------------------ |
| |
| Function: h264bsdResetDpb |
| |
| Functional description: |
| Function to reset DPB. This function should be called when an IDR |
| slice (other than the first) activates new sequence parameter set. |
| Function calls h264bsdFreeDpb to free old allocated memories and |
| h264bsdInitDpb to re-initialize the DPB. Same inputs, outputs and |
| returns as for h264bsdInitDpb. |
| |
| ------------------------------------------------------------------------------*/ |
| |
| u32 h264bsdResetDpb( |
| dpbStorage_t *dpb, |
| u32 picSizeInMbs, |
| u32 dpbSize, |
| u32 maxRefFrames, |
| u32 maxFrameNum, |
| u32 noReordering) |
| { |
| |
| /* Code */ |
| |
| ASSERT(picSizeInMbs); |
| ASSERT(maxRefFrames <= MAX_NUM_REF_PICS); |
| ASSERT(maxRefFrames <= dpbSize); |
| ASSERT(maxFrameNum); |
| ASSERT(dpbSize); |
| |
| h264bsdFreeDpb(dpb); |
| |
| return h264bsdInitDpb(dpb, picSizeInMbs, dpbSize, maxRefFrames, |
| maxFrameNum, noReordering); |
| } |
| |
| /*------------------------------------------------------------------------------ |
| |
| Function: h264bsdInitRefPicList |
| |
| Functional description: |
| Function to initialize reference picture list. Function just |
| sets pointers in the list according to pictures in the buffer. |
| The buffer is assumed to contain pictures sorted according to |
| what the H.264 standard says about initial reference picture list. |
| |
| Inputs: |
| dpb pointer to dpb data structure |
| |
| Outputs: |
| dpb 'list' field initialized |
| |
| Returns: |
| none |
| |
| ------------------------------------------------------------------------------*/ |
| |
| void h264bsdInitRefPicList(dpbStorage_t *dpb) |
| { |
| |
| /* Variables */ |
| |
| u32 i; |
| |
| /* Code */ |
| |
| for (i = 0; i < dpb->numRefFrames; i++) |
| dpb->list[i] = &dpb->buffer[i]; |
| |
| } |
| |
| /*------------------------------------------------------------------------------ |
| |
| Function: FindDpbPic |
| |
| Functional description: |
| Function to find a reference picture from the buffer. The picture |
| to be found is identified by picNum and isShortTerm flag. |
| |
| Returns: |
| index of the picture in the buffer |
| -1 if the specified picture was not found in the buffer |
| |
| ------------------------------------------------------------------------------*/ |
| |
| static i32 FindDpbPic(dpbStorage_t *dpb, i32 picNum, u32 isShortTerm) |
| { |
| |
| /* Variables */ |
| |
| u32 i = 0; |
| u32 found = HANTRO_FALSE; |
| |
| /* Code */ |
| |
| if (isShortTerm) |
| { |
| while (i < dpb->maxRefFrames && !found) |
| { |
| if (IS_SHORT_TERM(dpb->buffer[i]) && |
| dpb->buffer[i].picNum == picNum) |
| found = HANTRO_TRUE; |
| else |
| i++; |
| } |
| } |
| else |
| { |
| ASSERT(picNum >= 0); |
| while (i < dpb->maxRefFrames && !found) |
| { |
| if (IS_LONG_TERM(dpb->buffer[i]) && |
| dpb->buffer[i].picNum == picNum) |
| found = HANTRO_TRUE; |
| else |
| i++; |
| } |
| } |
| |
| if (found) |
| return((i32)i); |
| else |
| return(-1); |
| |
| } |
| |
| /*------------------------------------------------------------------------------ |
| |
| Function: SetPicNums |
| |
| Functional description: |
| Function to set picNum values for short-term pictures in the |
| buffer. Numbering of pictures is based on frame numbers and as |
| frame numbers are modulo maxFrameNum -> frame numbers of older |
| pictures in the buffer may be bigger than the currFrameNum. |
| picNums will be set so that current frame has the largest picNum |
| and all the short-term frames in the buffer will get smaller picNum |
| representing their "distance" from the current frame. This |
| function kind of maps the modulo arithmetic back to normal. |
| |
| ------------------------------------------------------------------------------*/ |
| |
| static void SetPicNums(dpbStorage_t *dpb, u32 currFrameNum) |
| { |
| |
| /* Variables */ |
| |
| u32 i; |
| i32 frameNumWrap; |
| |
| /* Code */ |
| |
| ASSERT(dpb); |
| ASSERT(currFrameNum < dpb->maxFrameNum); |
| |
| for (i = 0; i < dpb->numRefFrames; i++) |
| if (IS_SHORT_TERM(dpb->buffer[i])) |
| { |
| if (dpb->buffer[i].frameNum > currFrameNum) |
| frameNumWrap = |
| (i32)dpb->buffer[i].frameNum - (i32)dpb->maxFrameNum; |
| else |
| frameNumWrap = (i32)dpb->buffer[i].frameNum; |
| dpb->buffer[i].picNum = frameNumWrap; |
| } |
| |
| } |
| |
| /*------------------------------------------------------------------------------ |
| |
| Function: h264bsdCheckGapsInFrameNum |
| |
| Functional description: |
| Function to check gaps in frame_num and generate non-existing |
| (short term) reference pictures if necessary. This function should |
| be called only for non-IDR pictures. |
| |
| Inputs: |
| dpb pointer to dpb data structure |
| frameNum frame number of the current picture |
| isRefPic flag to indicate if current picture is a reference or |
| non-reference picture |
| gapsAllowed Flag which indicates active SPS stance on whether |
| to allow gaps |
| |
| Outputs: |
| dpb 'buffer' possibly modified by inserting non-existing |
| pictures with sliding window marking process |
| |
| Returns: |
| HANTRO_OK success |
| HANTRO_NOK error in sliding window reference picture marking or |
| frameNum equal to previous reference frame used for |
| a reference picture |
| |
| ------------------------------------------------------------------------------*/ |
| |
| u32 h264bsdCheckGapsInFrameNum(dpbStorage_t *dpb, u32 frameNum, u32 isRefPic, |
| u32 gapsAllowed) |
| { |
| |
| /* Variables */ |
| |
| u32 unUsedShortTermFrameNum; |
| u8 *tmp; |
| |
| /* Code */ |
| |
| ASSERT(dpb); |
| ASSERT(dpb->fullness <= dpb->dpbSize); |
| ASSERT(frameNum < dpb->maxFrameNum); |
| |
| dpb->numOut = 0; |
| dpb->outIndex = 0; |
| |
| if(!gapsAllowed) |
| return(HANTRO_OK); |
| |
| if ( (frameNum != dpb->prevRefFrameNum) && |
| (frameNum != ((dpb->prevRefFrameNum + 1) % dpb->maxFrameNum))) |
| { |
| |
| unUsedShortTermFrameNum = (dpb->prevRefFrameNum + 1) % dpb->maxFrameNum; |
| |
| /* store data pointer of last buffer position to be used as next |
| * "allocated" data pointer if last buffer position after this process |
| * contains data pointer located in outBuf (buffer placed in the output |
| * shall not be overwritten by the current picture) */ |
| tmp = dpb->buffer[dpb->dpbSize].data; |
| do |
| { |
| SetPicNums(dpb, unUsedShortTermFrameNum); |
| |
| if (SlidingWindowRefPicMarking(dpb) != HANTRO_OK) |
| { |
| return(HANTRO_NOK); |
| } |
| |
| /* output pictures if buffer full */ |
| while (dpb->fullness >= dpb->dpbSize) |
| { |
| #ifdef _ASSERT_USED |
| ASSERT(!dpb->noReordering); |
| ASSERT(OutputPicture(dpb) == HANTRO_OK); |
| #else |
| OutputPicture(dpb); |
| #endif |
| } |
| |
| /* add to end of list */ |
| ASSERT( !dpb->buffer[dpb->dpbSize].toBeDisplayed && |
| !IS_REFERENCE(dpb->buffer[dpb->dpbSize]) ); |
| dpb->buffer[dpb->dpbSize].status = NON_EXISTING; |
| dpb->buffer[dpb->dpbSize].frameNum = unUsedShortTermFrameNum; |
| dpb->buffer[dpb->dpbSize].picNum = (i32)unUsedShortTermFrameNum; |
| dpb->buffer[dpb->dpbSize].picOrderCnt = 0; |
| dpb->buffer[dpb->dpbSize].toBeDisplayed = HANTRO_FALSE; |
| dpb->fullness++; |
| dpb->numRefFrames++; |
| |
| /* sort the buffer */ |
| ShellSort(dpb->buffer, dpb->dpbSize+1); |
| |
| unUsedShortTermFrameNum = (unUsedShortTermFrameNum + 1) % |
| dpb->maxFrameNum; |
| |
| } while (unUsedShortTermFrameNum != frameNum); |
| |
| /* pictures placed in output buffer -> check that 'data' in |
| * buffer position dpbSize is not in the output buffer (this will be |
| * "allocated" by h264bsdAllocateDpbImage). If it is -> exchange data |
| * pointer with the one stored in the beginning */ |
| if (dpb->numOut) |
| { |
| u32 i; |
| |
| for (i = 0; i < dpb->numOut; i++) |
| { |
| if (dpb->outBuf[i].data == dpb->buffer[dpb->dpbSize].data) |
| { |
| /* find buffer position containing data pointer stored in |
| * tmp */ |
| for (i = 0; i < dpb->dpbSize; i++) |
| { |
| if (dpb->buffer[i].data == tmp) |
| { |
| dpb->buffer[i].data = |
| dpb->buffer[dpb->dpbSize].data; |
| dpb->buffer[dpb->dpbSize].data = tmp; |
| break; |
| } |
| } |
| ASSERT(i < dpb->dpbSize); |
| break; |
| } |
| } |
| } |
| } |
| /* frameNum for reference pictures shall not be the same as for previous |
| * reference picture, otherwise accesses to pictures in the buffer cannot |
| * be solved unambiguously */ |
| else if (isRefPic && frameNum == dpb->prevRefFrameNum) |
| { |
| return(HANTRO_NOK); |
| } |
| |
| /* save current frame_num in prevRefFrameNum. For non-reference frame |
| * prevFrameNum is set to frame number of last non-existing frame above */ |
| if (isRefPic) |
| dpb->prevRefFrameNum = frameNum; |
| else if (frameNum != dpb->prevRefFrameNum) |
| { |
| dpb->prevRefFrameNum = |
| (frameNum + dpb->maxFrameNum - 1) % dpb->maxFrameNum; |
| } |
| |
| return(HANTRO_OK); |
| |
| } |
| |
| /*------------------------------------------------------------------------------ |
| |
| Function: FindSmallestPicOrderCnt |
| |
| Functional description: |
| Function to find picture with smallest picture order count. This |
| will be the next picture in display order. |
| |
| Returns: |
| pointer to the picture, NULL if no pictures to be displayed |
| |
| ------------------------------------------------------------------------------*/ |
| |
| dpbPicture_t* FindSmallestPicOrderCnt(dpbStorage_t *dpb) |
| { |
| |
| /* Variables */ |
| |
| u32 i; |
| i32 picOrderCnt; |
| dpbPicture_t *tmp; |
| |
| /* Code */ |
| |
| ASSERT(dpb); |
| |
| picOrderCnt = 0x7FFFFFFF; |
| tmp = NULL; |
| |
| for (i = 0; i <= dpb->dpbSize; i++) |
| { |
| if (dpb->buffer[i].toBeDisplayed && |
| (dpb->buffer[i].picOrderCnt < picOrderCnt)) |
| { |
| tmp = dpb->buffer + i; |
| picOrderCnt = dpb->buffer[i].picOrderCnt; |
| } |
| } |
| |
| return(tmp); |
| |
| } |
| |
| /*------------------------------------------------------------------------------ |
| |
| Function: OutputPicture |
| |
| Functional description: |
| Function to put next display order picture into the output buffer. |
| |
| Returns: |
| HANTRO_OK success |
| HANTRO_NOK no pictures to display |
| |
| ------------------------------------------------------------------------------*/ |
| |
| u32 OutputPicture(dpbStorage_t *dpb) |
| { |
| |
| /* Variables */ |
| |
| dpbPicture_t *tmp; |
| |
| /* Code */ |
| |
| ASSERT(dpb); |
| |
| if (dpb->noReordering) |
| return(HANTRO_NOK); |
| |
| tmp = FindSmallestPicOrderCnt(dpb); |
| |
| /* no pictures to be displayed */ |
| if (tmp == NULL) |
| return(HANTRO_NOK); |
| |
| dpb->outBuf[dpb->numOut].data = tmp->data; |
| dpb->outBuf[dpb->numOut].isIdr = tmp->isIdr; |
| dpb->outBuf[dpb->numOut].picId = tmp->picId; |
| dpb->outBuf[dpb->numOut].numErrMbs = tmp->numErrMbs; |
| dpb->numOut++; |
| |
| tmp->toBeDisplayed = HANTRO_FALSE; |
| if (!IS_REFERENCE(*tmp)) |
| { |
| dpb->fullness--; |
| } |
| |
| return(HANTRO_OK); |
| |
| } |
| |
| /*------------------------------------------------------------------------------ |
| |
| Function: h264bsdDpbOutputPicture |
| |
| Functional description: |
| Function to get next display order picture from the output buffer. |
| |
| Return: |
| pointer to output picture structure, NULL if no pictures to |
| display |
| |
| ------------------------------------------------------------------------------*/ |
| |
| dpbOutPicture_t* h264bsdDpbOutputPicture(dpbStorage_t *dpb) |
| { |
| |
| /* Variables */ |
| |
| /* Code */ |
| |
| ASSERT(dpb); |
| |
| if (dpb->outIndex < dpb->numOut) |
| return(dpb->outBuf + dpb->outIndex++); |
| else |
| return(NULL); |
| |
| } |
| |
| /*------------------------------------------------------------------------------ |
| |
| Function: h264bsdFlushDpb |
| |
| Functional description: |
| Function to flush the DPB. Function puts all pictures needed for |
| display into the output buffer. This function shall be called in |
| the end of the stream to obtain pictures buffered for display |
| re-ordering purposes. |
| |
| ------------------------------------------------------------------------------*/ |
| |
| void h264bsdFlushDpb(dpbStorage_t *dpb) |
| { |
| |
| /* don't do anything if buffer not reserved */ |
| if (dpb->buffer) |
| { |
| dpb->flushed = 1; |
| /* output all pictures */ |
| while (OutputPicture(dpb) == HANTRO_OK) |
| ; |
| } |
| |
| } |
| |
| /*------------------------------------------------------------------------------ |
| |
| Function: h264bsdFreeDpb |
| |
| Functional description: |
| Function to free memories reserved for the DPB. |
| |
| ------------------------------------------------------------------------------*/ |
| |
| void h264bsdFreeDpb(dpbStorage_t *dpb) |
| { |
| |
| /* Variables */ |
| |
| u32 i; |
| |
| /* Code */ |
| |
| ASSERT(dpb); |
| |
| if (dpb->buffer) |
| { |
| for (i = 0; i < dpb->dpbSize+1; i++) |
| { |
| FREE(dpb->buffer[i].pAllocatedData); |
| } |
| } |
| FREE(dpb->buffer); |
| FREE(dpb->list); |
| FREE(dpb->outBuf); |
| |
| } |
| |
| /*------------------------------------------------------------------------------ |
| |
| Function: ShellSort |
| |
| Functional description: |
| Sort pictures in the buffer. Function implements Shell's method, |
| i.e. diminishing increment sort. See e.g. "Numerical Recipes in C" |
| for more information. |
| |
| ------------------------------------------------------------------------------*/ |
| |
| static void ShellSort(dpbPicture_t *pPic, u32 num) |
| { |
| |
| u32 i, j; |
| u32 step; |
| dpbPicture_t tmpPic; |
| |
| step = 7; |
| |
| while (step) |
| { |
| for (i = step; i < num; i++) |
| { |
| tmpPic = pPic[i]; |
| j = i; |
| while (j >= step && ComparePictures(pPic + j - step, &tmpPic) > 0) |
| { |
| pPic[j] = pPic[j-step]; |
| j -= step; |
| } |
| pPic[j] = tmpPic; |
| } |
| step >>= 1; |
| } |
| |
| } |
| |
