| /*! | |
| ***************************************************************************** | |
| * | |
| * \file fmo.c | |
| * | |
| * \brief | |
| * Support for Flexible Macroblock Ordering for different Slice Group Modes: MBAmap handling | |
| * | |
| * \date | |
| * 16 June, 2002 Modified April 25, 2004 | |
| * | |
| * \author | |
| * Stephan Wenger stewe@cs.tu-berlin.de | |
| * Dong Wang Dong.Wang@bristol.ac.uk | |
| * | |
| *****************************************************************************/ | |
| /*! | |
| **************************************************************************** | |
| * Notes by Dong Wang (April 25 2004) | |
| * | |
| * Source codes are modified to support 7 slice group types (fmo modes). | |
| * The functions for generating map are very similar to that in decoder, but have | |
| * a little difference. | |
| * | |
| * The MB map is calculated at the beginning of coding of each picture (frame or field). | |
| * | |
| * 'slice_group_change_cycle' in structure 'ImageParameters' is the syntax in the slice | |
| * header. It's set to be 1 before the initialization of FMO in function code_a_picture(). | |
| * It can be changed every time if needed. | |
| * | |
| **************************************************************************** | |
| */ | |
| /*! | |
| ***************************************************************************** | |
| * How does a MBAmap look like? | |
| * | |
| * An MBAmap is a one-diemnsional array of ints. Each int | |
| * represents an MB in scan order. A zero or positive value represents | |
| * a slice group ID. Negative values are reserved for future extensions. | |
| * The numbering range for the SliceGroupIDs is 0..7 as per JVT-C167. | |
| * | |
| * This module contains a static variable MBAmap. This is the MBAmap of the | |
| * picture currently coded. It can be accessed only through the access | |
| * functions. | |
| ***************************************************************************** | |
| */ | |
| //#define PRINT_FMO_MAPS 1 | |
| #include <stdlib.h> | |
| #include <string.h> | |
| #include <assert.h> | |
| #include <memory.h> | |
| #include "global.h" | |
| #include "fmo.h" | |
| static int FirstMBInSlice[MAXSLICEGROUPIDS]; | |
| byte *MBAmap = NULL; | |
| byte *MapUnitToSliceGroupMap = NULL; | |
| unsigned int PicSizeInMapUnits; | |
| static void FmoGenerateType0MapUnitMap (ImageParameters * img, pic_parameter_set_rbsp_t * pps); | |
| static void FmoGenerateType1MapUnitMap (ImageParameters * img, pic_parameter_set_rbsp_t * pps); | |
| static void FmoGenerateType2MapUnitMap (ImageParameters * img, pic_parameter_set_rbsp_t * pps); | |
| static void FmoGenerateType3MapUnitMap (ImageParameters * img, pic_parameter_set_rbsp_t * pps); | |
| static void FmoGenerateType4MapUnitMap (ImageParameters * img, pic_parameter_set_rbsp_t * pps); | |
| static void FmoGenerateType5MapUnitMap (ImageParameters * img, pic_parameter_set_rbsp_t * pps); | |
| static void FmoGenerateType6MapUnitMap (ImageParameters * img, pic_parameter_set_rbsp_t * pps); | |
| static int FmoGenerateMapUnitToSliceGroupMap (ImageParameters * img, pic_parameter_set_rbsp_t * pps); | |
| static int FmoGenerateMBAmap (ImageParameters * img, seq_parameter_set_rbsp_t* sps); | |
| /*! | |
| ************************************************************************ | |
| * \brief | |
| * Generates MapUnitToSliceGroupMap | |
| * | |
| * \param img | |
| * Image Parameter to be used for map generation | |
| * \param pps | |
| * Picture Parameter set to be used for map generation | |
| * | |
| ************************************************************************ | |
| */ | |
| static int FmoGenerateMapUnitToSliceGroupMap (ImageParameters * img, pic_parameter_set_rbsp_t * pps) | |
| { | |
| PicSizeInMapUnits = img->PicHeightInMapUnits * img->PicWidthInMbs; | |
| if (pps->slice_group_map_type == 6) | |
| { | |
| if ((pps->pic_size_in_map_units_minus1+1) != PicSizeInMapUnits) | |
| { | |
| error ("wrong pps->pic_size_in_map_units_minus1 for used SPS and FMO type 6", 500); | |
| } | |
| } | |
| // allocate memory for MapUnitToSliceGroupMap | |
| if (MapUnitToSliceGroupMap) | |
| free (MapUnitToSliceGroupMap); | |
| if ((MapUnitToSliceGroupMap = malloc ((PicSizeInMapUnits) * sizeof (byte))) == NULL) | |
| { | |
| printf ("cannot allocated %d bytes for MapUnitToSliceGroupMap, exit\n", (int) ( PicSizeInMapUnits * sizeof (byte))); | |
| exit (-1); | |
| } | |
| if (pps->num_slice_groups_minus1 == 0) // only one slice group | |
| { | |
| memset (MapUnitToSliceGroupMap, 0, PicSizeInMapUnits * sizeof (byte)); | |
| return 0; | |
| } | |
| switch (pps->slice_group_map_type) | |
| { | |
| case 0: | |
| FmoGenerateType0MapUnitMap (img, pps); | |
| break; | |
| case 1: | |
| FmoGenerateType1MapUnitMap (img, pps); | |
| break; | |
| case 2: | |
| FmoGenerateType2MapUnitMap (img, pps); | |
| break; | |
| case 3: | |
| FmoGenerateType3MapUnitMap (img, pps); | |
| break; | |
| case 4: | |
| FmoGenerateType4MapUnitMap (img, pps); | |
| break; | |
| case 5: | |
| FmoGenerateType5MapUnitMap (img, pps); | |
| break; | |
| case 6: | |
| FmoGenerateType6MapUnitMap (img, pps); | |
| break; | |
| default: | |
| printf ("Illegal slice_group_map_type %d , exit \n", pps->slice_group_map_type); | |
| exit (-1); | |
| } | |
| return 0; | |
| } | |
| /*! | |
| ************************************************************************ | |
| * \brief | |
| * Generates MBAmap from MapUnitToSliceGroupMap | |
| * | |
| * \param img | |
| * Image Parameter to be used for map generation | |
| * \param sps | |
| * Sequence Parameter set to be used for map generation | |
| * | |
| ************************************************************************ | |
| */ | |
| static int FmoGenerateMBAmap (ImageParameters * img, seq_parameter_set_rbsp_t* sps) | |
| { | |
| unsigned i; | |
| // allocate memory for MBAmap | |
| if (MBAmap) | |
| free (MBAmap); | |
| if ((MBAmap = malloc ((img->PicSizeInMbs) * sizeof (byte))) == NULL) | |
| { | |
| printf ("cannot allocated %d bytes for MBAmap, exit\n", (int) ((img->PicSizeInMbs) * sizeof (byte))); | |
| exit (-1); | |
| } | |
| if ((sps->frame_mbs_only_flag) || img->field_picture) | |
| { | |
| for (i=0; i<img->PicSizeInMbs; i++) | |
| { | |
| MBAmap[i] = MapUnitToSliceGroupMap[i]; | |
| } | |
| } | |
| else | |
| if (sps->mb_adaptive_frame_field_flag && (! img->field_picture)) | |
| { | |
| for (i=0; i<img->PicSizeInMbs; i++) | |
| { | |
| MBAmap[i] = MapUnitToSliceGroupMap[i/2]; | |
| } | |
| } | |
| else | |
| { | |
| for (i=0; i<img->PicSizeInMbs; i++) | |
| { | |
| MBAmap[i] = MapUnitToSliceGroupMap[(i/(2*img->PicWidthInMbs))*img->PicWidthInMbs+(i%img->PicWidthInMbs)]; | |
| } | |
| } | |
| return 0; | |
| } | |
| /*! | |
| ************************************************************************ | |
| * \brief | |
| * FMO initialization: Generates MapUnitToSliceGroupMap and MBAmap. | |
| * | |
| * \param img | |
| * Image Parameter to be used for map generation | |
| * \param pps | |
| * Picture Parameter set to be used for map generation | |
| * \param sps | |
| * Sequence Parameter set to be used for map generation | |
| ************************************************************************ | |
| */ | |
| int FmoInit(ImageParameters * img, pic_parameter_set_rbsp_t * pps, seq_parameter_set_rbsp_t * sps) | |
| { | |
| #ifdef PRINT_FMO_MAPS | |
| unsigned i,j; | |
| int bottom; | |
| #endif | |
| int k; | |
| for (k=0;k<MAXSLICEGROUPIDS;k++) | |
| FirstMBInSlice[k] = -1; | |
| FmoGenerateMapUnitToSliceGroupMap(img, pps); | |
| FmoGenerateMBAmap(img, sps); | |
| #ifdef PRINT_FMO_MAPS | |
| printf("\n"); | |
| printf("FMO Map (Units):\n"); | |
| for (j=0; j<img->PicHeightInMapUnits; j++) | |
| { | |
| for (i=0; i<img->PicWidthInMbs; i++) | |
| { | |
| printf("%d ",MapUnitToSliceGroupMap[i+j*img->PicWidthInMbs]); | |
| } | |
| printf("\n"); | |
| } | |
| printf("\n"); | |
| if(sps->mb_adaptive_frame_field_flag==0) | |
| { | |
| printf("FMO Map (Mb):\n"); | |
| for (j=0; j<(img->PicSizeInMbs/img->PicWidthInMbs); j++) | |
| { | |
| for (i=0; i<img->PicWidthInMbs; i++) | |
| { | |
| printf("%d ",MBAmap[i+j*img->PicWidthInMbs]); | |
| } | |
| printf("\n"); | |
| } | |
| printf("\n"); | |
| } | |
| else | |
| { | |
| printf("FMO Map (Mb in scan order for MBAFF):\n"); | |
| for (j=0; j<(img->PicSizeInMbs/img->PicWidthInMbs); j++) | |
| { | |
| for (i=0; i<img->PicWidthInMbs; i++) | |
| { | |
| bottom=(j%2); | |
| printf("%d ",MBAmap[(j-bottom)*img->PicWidthInMbs+i*2+bottom]); | |
| } | |
| printf("\n"); | |
| } | |
| printf("\n"); | |
| } | |
| #endif | |
| return 0; | |
| } | |
| /*! | |
| ************************************************************************ | |
| * \brief | |
| * Free memory if allocated by FMO functions | |
| ************************************************************************ | |
| */ | |
| void FmoUninit() | |
| { | |
| if (MBAmap) | |
| { | |
| free (MBAmap); | |
| MBAmap = NULL; | |
| } | |
| if (MapUnitToSliceGroupMap) | |
| { | |
| free (MapUnitToSliceGroupMap); | |
| MapUnitToSliceGroupMap = NULL; | |
| } | |
| } | |
| /*! | |
| ************************************************************************ | |
| * \brief | |
| * Generate interleaved slice group map type MapUnit map (type 0) | |
| * | |
| * \param img | |
| * Image Parameter to be used for map generation | |
| * \param pps | |
| * Picture Parameter set to be used for map generation | |
| ************************************************************************ | |
| */ | |
| static void FmoGenerateType0MapUnitMap (ImageParameters * img, pic_parameter_set_rbsp_t * pps ) | |
| { | |
| unsigned iGroup, j; | |
| unsigned i = 0; | |
| do | |
| { | |
| for( iGroup = 0; | |
| (iGroup <= pps->num_slice_groups_minus1) && (i < PicSizeInMapUnits); | |
| i += pps->run_length_minus1[iGroup++] + 1) | |
| { | |
| for( j = 0; j <= pps->run_length_minus1[ iGroup ] && i + j < PicSizeInMapUnits; j++ ) | |
| MapUnitToSliceGroupMap[i+j] = iGroup; | |
| } | |
| } | |
| while( i < PicSizeInMapUnits ); | |
| } | |
| /*! | |
| ************************************************************************ | |
| * \brief | |
| * Generate dispersed slice group map type MapUnit map (type 1) | |
| * | |
| * \param img | |
| * Image Parameter to be used for map generation | |
| * \param pps | |
| * Picture Parameter set to be used for map generation | |
| ************************************************************************ | |
| */ | |
| static void FmoGenerateType1MapUnitMap (ImageParameters * img, pic_parameter_set_rbsp_t * pps ) | |
| { | |
| unsigned i; | |
| for( i = 0; i < PicSizeInMapUnits; i++ ) | |
| { | |
| MapUnitToSliceGroupMap[i] = ((i%img->PicWidthInMbs)+(((i/img->PicWidthInMbs)*(pps->num_slice_groups_minus1+1))/2)) | |
| %(pps->num_slice_groups_minus1+1); | |
| } | |
| } | |
| /*! | |
| ************************************************************************ | |
| * \brief | |
| * Generate foreground with left-over slice group map type MapUnit map (type 2) | |
| * | |
| * \param img | |
| * Image Parameter to be used for map generation | |
| * \param pps | |
| * Picture Parameter set to be used for map generation | |
| ************************************************************************ | |
| */ | |
| static void FmoGenerateType2MapUnitMap (ImageParameters * img, pic_parameter_set_rbsp_t * pps ) | |
| { | |
| int iGroup; | |
| unsigned i, x, y; | |
| unsigned yTopLeft, xTopLeft, yBottomRight, xBottomRight; | |
| for( i = 0; i < PicSizeInMapUnits; i++ ) | |
| MapUnitToSliceGroupMap[ i ] = pps->num_slice_groups_minus1; | |
| for( iGroup = pps->num_slice_groups_minus1 - 1 ; iGroup >= 0; iGroup-- ) | |
| { | |
| yTopLeft = pps->top_left[ iGroup ] / img->PicWidthInMbs; | |
| xTopLeft = pps->top_left[ iGroup ] % img->PicWidthInMbs; | |
| yBottomRight = pps->bottom_right[ iGroup ] / img->PicWidthInMbs; | |
| xBottomRight = pps->bottom_right[ iGroup ] % img->PicWidthInMbs; | |
| for( y = yTopLeft; y <= yBottomRight; y++ ) | |
| for( x = xTopLeft; x <= xBottomRight; x++ ) | |
| MapUnitToSliceGroupMap[ y * img->PicWidthInMbs + x ] = iGroup; | |
| } | |
| } | |
| /*! | |
| ************************************************************************ | |
| * \brief | |
| * Generate box-out slice group map type MapUnit map (type 3) | |
| * | |
| * \param img | |
| * Image Parameter to be used for map generation | |
| * \param pps | |
| * Picture Parameter set to be used for map generation | |
| ************************************************************************ | |
| */ | |
| static void FmoGenerateType3MapUnitMap (ImageParameters * img, pic_parameter_set_rbsp_t * pps ) | |
| { | |
| unsigned i, k; | |
| int leftBound, topBound, rightBound, bottomBound; | |
| int x, y, xDir, yDir; | |
| int mapUnitVacant; | |
| unsigned mapUnitsInSliceGroup0 = imin((pps->slice_group_change_rate_minus1 + 1) * img->slice_group_change_cycle, PicSizeInMapUnits); | |
| for( i = 0; i < PicSizeInMapUnits; i++ ) | |
| MapUnitToSliceGroupMap[ i ] = 2; | |
| x = ( img->PicWidthInMbs - pps->slice_group_change_direction_flag ) / 2; | |
| y = ( img->PicHeightInMapUnits - pps->slice_group_change_direction_flag ) / 2; | |
| leftBound = x; | |
| topBound = y; | |
| rightBound = x; | |
| bottomBound = y; | |
| xDir = pps->slice_group_change_direction_flag - 1; | |
| yDir = pps->slice_group_change_direction_flag; | |
| for( k = 0; k < PicSizeInMapUnits; k += mapUnitVacant ) | |
| { | |
| mapUnitVacant = ( MapUnitToSliceGroupMap[ y * img->PicWidthInMbs + x ] == 2 ); | |
| if( mapUnitVacant ) | |
| MapUnitToSliceGroupMap[ y * img->PicWidthInMbs + x ] = ( k >= mapUnitsInSliceGroup0 ); | |
| if( xDir == -1 && x == leftBound ) | |
| { | |
| leftBound = imax( leftBound - 1, 0 ); | |
| x = leftBound; | |
| xDir = 0; | |
| yDir = 2 * pps->slice_group_change_direction_flag - 1; | |
| } | |
| else | |
| if( xDir == 1 && x == rightBound ) | |
| { | |
| rightBound = imin( rightBound + 1, (int)img->PicWidthInMbs - 1 ); | |
| x = rightBound; | |
| xDir = 0; | |
| yDir = 1 - 2 * pps->slice_group_change_direction_flag; | |
| } | |
| else | |
| if( yDir == -1 && y == topBound ) | |
| { | |
| topBound = imax( topBound - 1, 0 ); | |
| y = topBound; | |
| xDir = 1 - 2 * pps->slice_group_change_direction_flag; | |
| yDir = 0; | |
| } | |
| else | |
| if( yDir == 1 && y == bottomBound ) | |
| { | |
| bottomBound = imin( bottomBound + 1, (int)img->PicHeightInMapUnits - 1 ); | |
| y = bottomBound; | |
| xDir = 2 * pps->slice_group_change_direction_flag - 1; | |
| yDir = 0; | |
| } | |
| else | |
| { | |
| x = x + xDir; | |
| y = y + yDir; | |
| } | |
| } | |
| } | |
| /*! | |
| ************************************************************************ | |
| * \brief | |
| * Generate raster scan slice group map type MapUnit map (type 4) | |
| * | |
| * \param img | |
| * Image Parameter to be used for map generation | |
| * \param pps | |
| * Picture Parameter set to be used for map generation | |
| ************************************************************************ | |
| */ | |
| static void FmoGenerateType4MapUnitMap (ImageParameters * img, pic_parameter_set_rbsp_t * pps ) | |
| { | |
| unsigned mapUnitsInSliceGroup0 = imin((pps->slice_group_change_rate_minus1 + 1) * img->slice_group_change_cycle, PicSizeInMapUnits); | |
| unsigned sizeOfUpperLeftGroup = pps->slice_group_change_direction_flag ? ( PicSizeInMapUnits - mapUnitsInSliceGroup0 ) : mapUnitsInSliceGroup0; | |
| unsigned i; | |
| for( i = 0; i < PicSizeInMapUnits; i++ ) | |
| if( i < sizeOfUpperLeftGroup ) | |
| MapUnitToSliceGroupMap[ i ] = pps->slice_group_change_direction_flag; | |
| else | |
| MapUnitToSliceGroupMap[ i ] = 1 - pps->slice_group_change_direction_flag; | |
| } | |
| /*! | |
| ************************************************************************ | |
| * \brief | |
| * Generate wipe slice group map type MapUnit map (type 5) | |
| * | |
| * \param img | |
| * Image Parameter to be used for map generation | |
| * \param pps | |
| * Picture Parameter set to be used for map generation | |
| ************************************************************************ | |
| */ | |
| static void FmoGenerateType5MapUnitMap (ImageParameters * img, pic_parameter_set_rbsp_t * pps ) | |
| { | |
| unsigned mapUnitsInSliceGroup0 = imin((pps->slice_group_change_rate_minus1 + 1) * img->slice_group_change_cycle, PicSizeInMapUnits); | |
| unsigned sizeOfUpperLeftGroup = pps->slice_group_change_direction_flag ? ( PicSizeInMapUnits - mapUnitsInSliceGroup0 ) : mapUnitsInSliceGroup0; | |
| unsigned i,j, k = 0; | |
| for( j = 0; j < img->PicWidthInMbs; j++ ) | |
| for( i = 0; i < img->PicHeightInMapUnits; i++ ) | |
| if( k++ < sizeOfUpperLeftGroup ) | |
| MapUnitToSliceGroupMap[ i * img->PicWidthInMbs + j ] = pps->slice_group_change_direction_flag; | |
| else | |
| MapUnitToSliceGroupMap[ i * img->PicWidthInMbs + j ] = 1 - pps->slice_group_change_direction_flag; | |
| } | |
| /*! | |
| ************************************************************************ | |
| * \brief | |
| * Generate explicit slice group map type MapUnit map (type 6) | |
| * | |
| * \param img | |
| * Image Parameter to be used for map generation | |
| * \param pps | |
| * Picture Parameter set to be used for map generation | |
| ************************************************************************ | |
| */ | |
| static void FmoGenerateType6MapUnitMap (ImageParameters * img, pic_parameter_set_rbsp_t * pps ) | |
| { | |
| unsigned i; | |
| for (i=0; i<PicSizeInMapUnits; i++) | |
| { | |
| MapUnitToSliceGroupMap[i] = pps->slice_group_id[i]; | |
| } | |
| } | |
| /*! | |
| ************************************************************************ | |
| * \brief | |
| * FmoStartPicture: initializes FMO at the begin of each new picture | |
| * | |
| * \par Input: | |
| * None | |
| ************************************************************************ | |
| */ | |
| int FmoStartPicture () | |
| { | |
| int i; | |
| assert (MBAmap != NULL); | |
| for (i=0; i<MAXSLICEGROUPIDS; i++) | |
| FirstMBInSlice[i] = FmoGetFirstMBOfSliceGroup (i); | |
| return 0; | |
| } | |
| /*! | |
| ************************************************************************ | |
| * \brief | |
| * FmoEndPicture: Ends the Scattered Slices Module (called once | |
| * per picture). | |
| * | |
| * \par Input: | |
| * None | |
| ************************************************************************ | |
| */ | |
| int FmoEndPicture () | |
| { | |
| // Do nothing | |
| return 0; | |
| } | |
| /*! | |
| ************************************************************************ | |
| * \brief | |
| * FmoMB2Slice: Returns SliceID for a given MB | |
| * | |
| * \par Input: | |
| * Macroblock Nr (in scan order) | |
| ************************************************************************ | |
| */ | |
| int FmoMB2SliceGroup ( int mb) | |
| { | |
| assert (mb < (int)img->PicSizeInMbs); | |
| assert (MBAmap != NULL); | |
| return MBAmap[mb]; | |
| } | |
| /*! | |
| ************************************************************************ | |
| * \brief | |
| * FmoGetNextMBBr: Returns the MB-Nr (in scan order) of the next | |
| * MB in the (FMO) Slice, -1 if the SliceGroup is finished | |
| * | |
| * \par Input: | |
| * CurrentMbNr | |
| ************************************************************************ | |
| */ | |
| int FmoGetNextMBNr (int CurrentMbNr) | |
| { | |
| int SliceGroupID = FmoMB2SliceGroup (CurrentMbNr); | |
| while (++CurrentMbNr<(int)img->PicSizeInMbs && MBAmap[CurrentMbNr] != SliceGroupID) | |
| ; | |
| if (CurrentMbNr >= (int)img->PicSizeInMbs) | |
| return -1; // No further MB in this slice (could be end of picture) | |
| else | |
| return CurrentMbNr; | |
| } | |
| /*! | |
| ************************************************************************ | |
| * \brief | |
| * FmoGetNextMBBr: Returns the MB-Nr (in scan order) of the next | |
| * MB in the (FMO) Slice, -1 if the SliceGroup is finished | |
| * | |
| * \par Input: | |
| * CurrentMbNr | |
| ************************************************************************ | |
| */ | |
| int FmoGetPreviousMBNr (int CurrentMbNr) | |
| { | |
| int SliceGroupID = FmoMB2SliceGroup (CurrentMbNr); | |
| CurrentMbNr--; | |
| while (CurrentMbNr>=0 && MBAmap[CurrentMbNr] != SliceGroupID) | |
| CurrentMbNr--; | |
| if (CurrentMbNr < 0) | |
| return -1; // No previous MB in this slice | |
| else | |
| return CurrentMbNr; | |
| } | |
| /*! | |
| ************************************************************************ | |
| * \brief | |
| * FmoGetFirstMBOfSliceGroup: Returns the MB-Nr (in scan order) of the | |
| * next first MB of the Slice group, -1 if no such MB exists | |
| * | |
| * \par Input: | |
| * SliceGroupID: Id of SliceGroup | |
| ************************************************************************ | |
| */ | |
| int FmoGetFirstMBOfSliceGroup (int SliceGroupID) | |
| { | |
| int i = 0; | |
| while ((i<(int)img->PicSizeInMbs) && (FmoMB2SliceGroup (i) != SliceGroupID)) | |
| i++; | |
| if (i < (int)img->PicSizeInMbs) | |
| return i; | |
| else | |
| return -1; | |
| } | |
| /*! | |
| ************************************************************************ | |
| * \brief | |
| * FmoGetLastCodedMBOfSlice: Returns the MB-Nr (in scan order) of | |
| * the last MB of the slice group | |
| * | |
| * \par Input: | |
| * SliceGroupID | |
| * \par Return | |
| * MB Nr in case of success (is always >= 0) | |
| * -1 if the SliceGroup doesn't exist | |
| ************************************************************************ | |
| */ | |
| int FmoGetLastCodedMBOfSliceGroup (int SliceGroupID) | |
| { | |
| int i; | |
| int LastMB = -1; | |
| for (i=0; i<(int)img->PicSizeInMbs; i++) | |
| if (FmoMB2SliceGroup (i) == SliceGroupID) | |
| LastMB = i; | |
| return LastMB; | |
| } | |
| void FmoSetLastMacroblockInSlice ( int mb) | |
| { | |
| // called by terminate_slice(), writes the last processed MB into the | |
| // FirstMBInSlice[MAXSLICEGROUPIDS] array. FmoGetFirstMacroblockInSlice() | |
| // uses this info to identify the first uncoded MB in each slice group | |
| int currSliceGroup = FmoMB2SliceGroup (mb); | |
| assert (mb >= 0); | |
| mb = FmoGetNextMBNr (mb); // The next (still uncoded) MB, or -1 if SG is finished | |
| FirstMBInSlice[currSliceGroup] = mb; | |
| } | |
| int FmoGetFirstMacroblockInSlice ( int SliceGroup) | |
| { | |
| return FirstMBInSlice[SliceGroup]; | |
| // returns the first uncoded MB in each slice group, -1 if there is no | |
| // more to do in this slice group | |
| } | |
| int FmoSliceGroupCompletelyCoded( int SliceGroupID) | |
| { | |
| if (FmoGetFirstMacroblockInSlice (SliceGroupID) < 0) // slice group completelty coded or not present | |
| return TRUE; | |
| else | |
| return FALSE; | |
| } | |