Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit ecd0813e authored by Chong Zhang's avatar Chong Zhang
Browse files

stagefright: renaming some variable in ItemTable 

Renamed most "imageIndex" to "itemIndex". This is a
refactoring with no functional change, in preparation
for upcoming changes to support image sequence retrieval,
as the image index will be referring to the index of
displayable images, instead of the index into item table.

bug: 67652588

Change-Id: If7fc51eb90df7e44e635a756f628a6d344155a79
parent 3d762515

media/extractors/mp4/ItemTable.cpp

+94 −130
Original line number Diff line number Diff line
@@ -470,50 +470,52 @@ struct ItemReference : public Box, public RefBase { 


    uint32_t itemId() { return mItemId; }



    void apply(KeyedVector<uint32_t, ImageItem> &itemIdToImageMap) const {

        ssize_t imageIndex = itemIdToImageMap.indexOfKey(mItemId);

    void apply(KeyedVector<uint32_t, ImageItem> &itemIdToItemMap) const;



private:

    uint32_t mItemId;

    uint32_t mRefIdSize;

    Vector<uint32_t> mRefs;



    DISALLOW_EVIL_CONSTRUCTORS(ItemReference);

};



void ItemReference::apply(KeyedVector<uint32_t, ImageItem> &itemIdToItemMap) const {

    ssize_t itemIndex = itemIdToItemMap.indexOfKey(mItemId);



    // ignore non-image items

        if (imageIndex < 0) {

    if (itemIndex < 0) {

        return;

    }



    ALOGV("attach reference type 0x%x to item id %d)", type(), mItemId);



    if (type() == FOURCC('d', 'i', 'm', 'g')) {

            ImageItem &image = itemIdToImageMap.editValueAt(imageIndex);

            if (!image.dimgRefs.empty()) {

        ImageItem &derivedImage = itemIdToItemMap.editValueAt(itemIndex);

        if (!derivedImage.dimgRefs.empty()) {

            ALOGW("dimgRefs if not clean!");

        }

            image.dimgRefs.appendVector(mRefs);

        derivedImage.dimgRefs.appendVector(mRefs);

    } else if (type() == FOURCC('t', 'h', 'm', 'b')) {

        for (size_t i = 0; i < mRefs.size(); i++) {

                imageIndex = itemIdToImageMap.indexOfKey(mRefs[i]);

            itemIndex = itemIdToItemMap.indexOfKey(mRefs[i]);



            // ignore non-image items

                if (imageIndex < 0) {

            if (itemIndex < 0) {

                continue;

            }

            ALOGV("Image item id %d uses thumbnail item id %d", mRefs[i], mItemId);

                ImageItem &image = itemIdToImageMap.editValueAt(imageIndex);

                if (!image.thumbnails.empty()) {

            ImageItem &masterImage = itemIdToItemMap.editValueAt(itemIndex);

            if (!masterImage.thumbnails.empty()) {

                ALOGW("already has thumbnails!");

            }

                image.thumbnails.push_back(mItemId);

            masterImage.thumbnails.push_back(mItemId);

        }

    } else {

        ALOGW("ignoring unsupported ref type 0x%x", type());

    }

}



private:

    uint32_t mItemId;

    uint32_t mRefIdSize;

    Vector<uint32_t> mRefs;



    DISALLOW_EVIL_CONSTRUCTORS(ItemReference);

};



status_t ItemReference::parse(off64_t offset, size_t size) {

    if (size < mRefIdSize + 2) {

        return ERROR_MALFORMED;
@@ -985,45 +987,7 @@ status_t InfeBox::parse(off64_t offset, size_t size, ItemInfo *itemInfo) { 
    }



    if (version() == 0 || version() == 1) {

        if (size < 4) {

            return ERROR_MALFORMED;

        }

        uint16_t item_id;

        if (!source()->getUInt16(offset, &item_id)) {

            return ERROR_IO;

        }

        ALOGV("item_id %d", item_id);

        uint16_t item_protection_index;

        if (!source()->getUInt16(offset + 2, &item_protection_index)) {

            return ERROR_IO;

        }

        offset += 4;

        size -= 4;



        String8 item_name;

        if (!parseNullTerminatedString(&offset, &size, &item_name)) {

            return ERROR_MALFORMED;

        }



        String8 content_type;

        if (!parseNullTerminatedString(&offset, &size, &content_type)) {

            return ERROR_MALFORMED;

        }



        String8 content_encoding;

        if (!parseNullTerminatedString(&offset, &size, &content_encoding)) {

            return ERROR_MALFORMED;

        }



        if (version() == 1) {

            uint32_t extension_type;

            if (!source()->getUInt32(offset, &extension_type)) {

                return ERROR_IO;

            }

            offset++;

            size--;

            // TODO: handle this case

        }

        return ERROR_UNSUPPORTED;

    } else { // version >= 2

        uint32_t item_id;

        size_t itemIdSize = (version() == 2) ? 2 : 4;
@@ -1140,11 +1104,10 @@ status_t IinfBox::onChunkData(uint32_t type, off64_t offset, size_t size) { 
    InfeBox infeBox(source());

    ItemInfo itemInfo;

    status_t err = infeBox.parse(offset, size, &itemInfo);

    if (err != OK) {

        return err;

    }

    if (err == OK) {

        mItemInfos->push_back(itemInfo);

        mHasGrids |= (itemInfo.itemType == FOURCC('g', 'r', 'i', 'd'));

    }

    return OK;

}
@@ -1156,7 +1119,7 @@ ItemTable::ItemTable(const sp<DataSource> &source) 
      mIdatOffset(0),

      mIdatSize(0),

      mImageItemsValid(false),

      mCurrentImageIndex(0) {

      mCurrentItemIndex(0) {

    mRequiredBoxes.insert('iprp');

    mRequiredBoxes.insert('iloc');

    mRequiredBoxes.insert('pitm');
@@ -1311,8 +1274,8 @@ status_t ItemTable::buildImageItemsIfPossible(uint32_t type) { 
            continue;

        }



        ssize_t imageIndex = mItemIdToImageMap.indexOfKey(info.itemId);

        if (imageIndex >= 0) {

        ssize_t itemIndex = mItemIdToItemMap.indexOfKey(info.itemId);

        if (itemIndex >= 0) {

            ALOGW("ignoring duplicate image item id %d", info.itemId);

            continue;

        }
@@ -1351,7 +1314,7 @@ status_t ItemTable::buildImageItemsIfPossible(uint32_t type) { 
            image.offset = offset;

            image.size = size;

        }

        mItemIdToImageMap.add(info.itemId, image);

        mItemIdToItemMap.add(info.itemId, image);

    }



    for (size_t i = 0; i < mAssociations.size(); i++) {
@@ -1359,7 +1322,7 @@ status_t ItemTable::buildImageItemsIfPossible(uint32_t type) { 
    }



    for (size_t i = 0; i < mItemReferences.size(); i++) {

        mItemReferences[i]->apply(mItemIdToImageMap);

        mItemReferences[i]->apply(mItemIdToItemMap);

    }



    mImageItemsValid = true;
@@ -1367,10 +1330,10 @@ status_t ItemTable::buildImageItemsIfPossible(uint32_t type) { 
}



void ItemTable::attachProperty(const AssociationEntry &association) {

    ssize_t imageIndex = mItemIdToImageMap.indexOfKey(association.itemId);

    ssize_t itemIndex = mItemIdToItemMap.indexOfKey(association.itemId);



    // ignore non-image items

    if (imageIndex < 0) {

    if (itemIndex < 0) {

        return;

    }
@@ -1384,7 +1347,7 @@ void ItemTable::attachProperty(const AssociationEntry &association) { 
            propertyIndex, association.itemId);



    mItemProperties[propertyIndex]->attachTo(

            mItemIdToImageMap.editValueAt(imageIndex));

            mItemIdToItemMap.editValueAt(itemIndex));

}



sp<MetaData> ItemTable::getImageMeta() {
@@ -1392,15 +1355,15 @@ sp<MetaData> ItemTable::getImageMeta() { 
        return NULL;

    }



    ssize_t imageIndex = mItemIdToImageMap.indexOfKey(mPrimaryItemId);

    if (imageIndex < 0) {

    ssize_t itemIndex = mItemIdToItemMap.indexOfKey(mPrimaryItemId);

    if (itemIndex < 0) {

        ALOGE("Primary item id %d not found!", mPrimaryItemId);

        return NULL;

    }



    ALOGV("primary image index %zu", imageIndex);

    ALOGV("primary item index %zu", itemIndex);



    const ImageItem *image = &mItemIdToImageMap[imageIndex];

    const ImageItem *image = &mItemIdToItemMap[itemIndex];



    sp<MetaData> meta = new MetaData;

    meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_HEVC);
@@ -1421,24 +1384,24 @@ sp<MetaData> ItemTable::getImageMeta() { 
    meta->setInt32(kKeyMaxInputSize, image->width * image->height * 1.5);



    if (!image->thumbnails.empty()) {

        ssize_t thumbnailIndex = mItemIdToImageMap.indexOfKey(image->thumbnails[0]);

        if (thumbnailIndex >= 0) {

            const ImageItem &thumbnail = mItemIdToImageMap[thumbnailIndex];

        ssize_t thumbItemIndex = mItemIdToItemMap.indexOfKey(image->thumbnails[0]);

        if (thumbItemIndex >= 0) {

            const ImageItem &thumbnail = mItemIdToItemMap[thumbItemIndex];



            meta->setInt32(kKeyThumbnailWidth, thumbnail.width);

            meta->setInt32(kKeyThumbnailHeight, thumbnail.height);

            meta->setData(kKeyThumbnailHVCC, kTypeHVCC,

                    thumbnail.hvcc->data(), thumbnail.hvcc->size());

            ALOGV("thumbnail meta: %dx%d, index %zd",

                    thumbnail.width, thumbnail.height, thumbnailIndex);

            ALOGV("thumbnail meta: %dx%d, item index %zd",

                    thumbnail.width, thumbnail.height, thumbItemIndex);

        } else {

            ALOGW("Referenced thumbnail does not exist!");

            ALOGW("%s: Referenced thumbnail does not exist!", __FUNCTION__);

        }

    }



    if (image->isGrid()) {

        ssize_t tileIndex = mItemIdToImageMap.indexOfKey(image->dimgRefs[0]);

        if (tileIndex < 0) {

        ssize_t tileItemIndex = mItemIdToItemMap.indexOfKey(image->dimgRefs[0]);

        if (tileItemIndex < 0) {

            return NULL;

        }

        // when there are tiles, (kKeyWidth, kKeyHeight) is the full tiled area,
@@ -1448,7 +1411,7 @@ sp<MetaData> ItemTable::getImageMeta() { 
        int32_t gridRows = image->rows, gridCols = image->columns;



        // point image to the first tile for grid size and HVCC

        image = &mItemIdToImageMap.editValueAt(tileIndex);

        image = &mItemIdToItemMap.editValueAt(tileItemIndex);

        meta->setInt32(kKeyWidth, image->width * gridCols);

        meta->setInt32(kKeyHeight, image->height * gridRows);

        meta->setInt32(kKeyGridWidth, image->width);
@@ -1457,7 +1420,7 @@ sp<MetaData> ItemTable::getImageMeta() { 
    }



    if (image->hvcc == NULL) {

        ALOGE("hvcc is missing!");

        ALOGE("%s: hvcc is missing for item index %zd!", __FUNCTION__, itemIndex);

        return NULL;

    }

    meta->setData(kKeyHVCC, kTypeHVCC, image->hvcc->data(), image->hvcc->size());
@@ -1469,87 +1432,88 @@ sp<MetaData> ItemTable::getImageMeta() { 
}



uint32_t ItemTable::countImages() const {

    return mImageItemsValid ? mItemIdToImageMap.size() : 0;

    return mImageItemsValid ? mItemIdToItemMap.size() : 0;

}



status_t ItemTable::findPrimaryImage(uint32_t *imageIndex) {

status_t ItemTable::findPrimaryImage(uint32_t *itemIndex) {

    if (!mImageItemsValid) {

        return INVALID_OPERATION;

    }



    ssize_t index = mItemIdToImageMap.indexOfKey(mPrimaryItemId);

    ssize_t index = mItemIdToItemMap.indexOfKey(mPrimaryItemId);

    if (index < 0) {

        return ERROR_MALFORMED;

    }



    *imageIndex = index;

    *itemIndex = index;

    return OK;

}



status_t ItemTable::findThumbnail(uint32_t *imageIndex) {

status_t ItemTable::findThumbnail(uint32_t *itemIndex) {

    if (!mImageItemsValid) {

        return INVALID_OPERATION;

    }



    ssize_t primaryIndex = mItemIdToImageMap.indexOfKey(mPrimaryItemId);

    if (primaryIndex < 0) {

        ALOGE("Primary item id %d not found!", mPrimaryItemId);

    ssize_t primaryItemIndex = mItemIdToItemMap.indexOfKey(mPrimaryItemId);

    if (primaryItemIndex < 0) {

        ALOGE("%s: Primary item id %d not found!", __FUNCTION__, mPrimaryItemId);

        return ERROR_MALFORMED;

    }



    const ImageItem &primaryImage = mItemIdToImageMap[primaryIndex];

    const ImageItem &primaryImage = mItemIdToItemMap[primaryItemIndex];

    if (primaryImage.thumbnails.empty()) {

        ALOGW("Using primary in place of thumbnail.");

        *imageIndex = primaryIndex;

        ALOGW("%s: Using primary in place of thumbnail.", __FUNCTION__);

        *itemIndex = primaryItemIndex;

        return OK;

    }



    ssize_t thumbnailIndex = mItemIdToImageMap.indexOfKey(

    ssize_t thumbItemIndex = mItemIdToItemMap.indexOfKey(

            primaryImage.thumbnails[0]);

    if (thumbnailIndex < 0) {

        ALOGE("Thumbnail item id %d not found!", primaryImage.thumbnails[0]);

    if (thumbItemIndex < 0) {

        ALOGE("%s: Thumbnail item id %d not found!",

                __FUNCTION__, primaryImage.thumbnails[0]);

        return ERROR_MALFORMED;

    }



    *imageIndex = thumbnailIndex;

    *itemIndex = thumbItemIndex;

    return OK;

}



status_t ItemTable::getImageOffsetAndSize(

        uint32_t *imageIndex, off64_t *offset, size_t *size) {

        uint32_t *itemIndex, off64_t *offset, size_t *size) {

    if (!mImageItemsValid) {

        return INVALID_OPERATION;

    }



    if (imageIndex != NULL) {

        if (*imageIndex >= mItemIdToImageMap.size()) {

            ALOGE("Bad image index!");

    if (itemIndex != NULL) {

        if (*itemIndex >= mItemIdToItemMap.size()) {

            ALOGE("%s: Bad item index!", __FUNCTION__);

            return BAD_VALUE;

        }

        mCurrentImageIndex = *imageIndex;

        mCurrentItemIndex = *itemIndex;

    }



    ImageItem &image = mItemIdToImageMap.editValueAt(mCurrentImageIndex);

    ImageItem &image = mItemIdToItemMap.editValueAt(mCurrentItemIndex);

    if (image.isGrid()) {

        uint32_t tileItemId;

        status_t err = image.getNextTileItemId(&tileItemId, imageIndex != NULL);

        status_t err = image.getNextTileItemId(&tileItemId, itemIndex != NULL);

        if (err != OK) {

            return err;

        }

        ssize_t tileImageIndex = mItemIdToImageMap.indexOfKey(tileItemId);

        if (tileImageIndex < 0) {

        ssize_t tileItemIndex = mItemIdToItemMap.indexOfKey(tileItemId);

        if (tileItemIndex < 0) {

            return ERROR_END_OF_STREAM;

        }

        *offset = mItemIdToImageMap[tileImageIndex].offset;

        *size = mItemIdToImageMap[tileImageIndex].size;

        *offset = mItemIdToItemMap[tileItemIndex].offset;

        *size = mItemIdToItemMap[tileItemIndex].size;

    } else {

        if (imageIndex == NULL) {

        if (itemIndex == NULL) {

            // For single images, we only allow it to be read once, after that

            // it's EOS.  New image index must be requested each time.

            // it's EOS.  New item index must be requested each time.

            return ERROR_END_OF_STREAM;

        }

        *offset = mItemIdToImageMap[mCurrentImageIndex].offset;

        *size = mItemIdToImageMap[mCurrentImageIndex].size;

        *offset = mItemIdToItemMap[mCurrentItemIndex].offset;

        *size = mItemIdToItemMap[mCurrentItemIndex].size;

    }



    return OK;

media/extractors/mp4/ItemTable.h

+2 −2
Original line number Diff line number Diff line
@@ -76,8 +76,8 @@ private: 
    std::set<uint32_t> mBoxesSeen;



    bool mImageItemsValid;

    uint32_t mCurrentImageIndex;

    KeyedVector<uint32_t, ImageItem> mItemIdToImageMap;

    uint32_t mCurrentItemIndex;

    KeyedVector<uint32_t, ImageItem> mItemIdToItemMap;



    status_t parseIlocBox(off64_t offset, size_t size);

    status_t parseIinfBox(off64_t offset, size_t size);