dsmcc.cpp

数字电视中间件小型库

                DSM_CC_TRACE_NUM("ModuleTracker", "Bad block payload size, instead received", block.payload_size, "8");
            #endif
            return false;
        }
    }
    else if(block.block_number == tracked_module.num_blocks - 1) {
        if(!(block.payload_size <= tracked_module.block_size)) {
            #ifdef DSM_CC_TRACE_MODULETRACKER
                DSM_CC_TRACE_NUM("ModuleTracker", "Bad block payload size, was expecting up to", tracked_module.block_size, "8");
                DSM_CC_TRACE_NUM("ModuleTracker", "Bad block payload size, instead received", block.payload_size, "8");
            #endif
            return false;
        }
    }
    else {
        #ifdef DSM_CC_TRACE_MODULETRACKER
            DSM_CC_TRACE_NUM("ModuleTracker", "Bad download block size for module_id", block.module_id, "4");
        #endif
        return false;
    }

    uint8_t* writebuf = contents + tracked_module.block_size * block.block_number;
    memcpy(writebuf, block.payload_pointer, block.payload_size);

    received_blocks[array_offset] |= mask;
    ++received_blocks_count;

    #ifdef DSM_CC_TRACE_MODULETRACKER
        dsmcc_trace("[ModuleTracker 0x%04x] Received block %d, (%d/%d remaining)\n", tracked_module.module_id, block.block_number, tracked_module.num_blocks - received_blocks_count, tracked_module.num_blocks);
    #endif

    return true;
}

    
DSM_CC::DownloadTracker::DownloadTracker(uint32_t id) :
    download_id(id),
    num_modules_tracked(0),
    num_modules_completed(0),
    allocated_memory(0)
{}

DSM_CC::DownloadTracker::~DownloadTracker() {
    module_tracker_map::const_iterator i;
    for (i = module_trackers.begin(); i != module_trackers.end(); ++i) {
        delete module_trackers[i.key()];
    }
}

bool DSM_CC::DownloadTracker::TrackModule(uint16_t module_id) {
    if(module_trackers.contains(module_id)) {
        return false;
    }

    module_trackers[module_id] = new ModuleTracker();

    if(module_trackers[module_id] == 0) {
        dsmcc_trace("[DownloadTracker 0x%08x] Failed to allocate new module tracker for module_id = 0x%04x\n", download_id, module_id);
        return false;
    }

    ++num_modules_tracked;
    dsmcc_trace("[DownloadTracker 0x%08x] Now tracking module_id = 0x%04x (but no parameters known yet)\n", download_id, module_id);

    return true;
}

bool DSM_CC::DownloadTracker::ModuleSetParameters(const tracked_module_t& module) {
    if(!module_trackers.contains(module.module_id)) {
        return false;
    }

    module_trackers[module.module_id]->SetParameters(module);

    allocated_memory += module.module_size;
    dsmcc_trace("[DownloadTracker 0x%08x] Parameters set for module_id = 0x%04x (%d bytes in %d blocks, %d modules total)\n", download_id, module.module_id, module.module_size, module.num_blocks, num_modules_tracked);
    //dsmcc_trace("[DownloadTracker 0x%08x] Total memory allocation is now %d bytes\n", download_id, allocated_memory);

    return true;
}

bool DSM_CC::DownloadTracker::UntrackModule(uint16_t module_id) {
    if(!module_trackers.contains(module_id)) {
        return false;
    }

    DSM_CC::ModuleTracker* mt = module_trackers[module_id];
    if(mt->Completed()) {
        --num_modules_completed;
    }

    if(mt->HaveParameters()) {
        tracked_module_t module = mt->GetParameters();
        allocated_memory -= module.module_size;
    }

    --num_modules_tracked;

    delete mt;
    module_trackers.remove(module_id);
    return true;
}

bool DSM_CC::DownloadTracker::ProcessDDB(const DownloadDataBlock& block) {
    if(!module_trackers.contains(block.module_id)) {
        #ifdef DSM_CC_TRACE_DOWNLOADTRACKER
            DSM_CC_TRACE_NUM("DownloadTracker", "Rejected DDB for unknown module_id", block.module_id, "4");
        #endif
        return true;
    }

    DSM_CC::ModuleTracker* mt = module_trackers[block.module_id];

    // If the module is complete, we don't care even if there's a new version floating around
    if(mt->Completed()) {
        return true;
    }

/*
    if(mt->HaveParameters()) {
        DSM_CC::tracked_module_t module = mt->GetParameters();
        if(module.module_version != block.module_version) {
            UntrackModule(module.module_id);
            TrackModule(module.module_id);
        }
    }
*/
    // We could check the versions here, but make sure that the ModuleTracker has received module info first
    /*
    DSM_CC::tracked_module_t module = mt->GetParameters();
    if(module.module_version != block.module_version) {
        // We have a new version of the module in the carousel, so don't do anything
        // Eventually, the DownloadTracker itself will reset
        #ifdef DSM_CC_TRACE_DOWNLOADTRACKER
            DSM_CC_TRACE_NUM("DownloadTracker", "Received block with different version for module_id", block.module_id, "4");
            DSM_CC_TRACE_NUM("DownloadTracker", "Our version is ", module.module_version, "4");
            DSM_CC_TRACE_NUM("DownloadTracker", "The received version is ", block.module_version, "4");
        #endif
        return false;
    }
    */

    bool retval = mt->ProcessDDB(block);

    if(mt->Completed()) {
        ++num_modules_completed;
        #ifdef DSM_CC_TRACE_DOWNLOADTRACKER
            dsmcc_trace("[DownloadTracker 0x%08x] COMPLETED module with module_id = 0x%04x (%d tracked, %d total completed)\n", download_id, block.module_id, num_modules_tracked, num_modules_completed);
        #endif
    }

    return retval;
}

bool DSM_CC::DownloadTracker::ProcessDII(const DownloadInfoIndication& indication, const BIOP::DIIModuleLoopItem& mitem) {
    if(indication.download_id != download_id) {
        return false;
    }

    if(!module_trackers.contains(mitem.module_id)) {
        return true;
    }

    tracked_module_t module;

    module.module_id             = mitem.module_id;
    module.module_version        = mitem.module_version;
    module.module_size           = mitem.module_size;
    module.num_blocks            = (mitem.module_size / indication.block_size) + (mitem.module_size % indication.block_size == 0 ? 0 : 1);
    module.block_size            = indication.block_size;
    module.z_compression_method  = mitem.module_info.z_compression_method;
    module.z_original_size       = mitem.module_info.z_original_size;

    return ModuleSetParameters(module);
}


void DSM_CC::sink(...) {}

bool DSM_CC::DownloadTracker::InterestedInObject(uint16_t module_id, uint32_t object_key, uint8_t key_length) {
    if(!module_trackers.contains(module_id)) {
        return false;
    }

    DSM_CC::ModuleTracker* mt = module_trackers[module_id];
    return mt->InterestedInObject(object_key, key_length);
}

void DSM_CC::DownloadTracker::MarkObject(uint16_t module_id, uint32_t object_key, uint8_t object_key_length, bool mark) {
    if(!module_trackers.contains(module_id)) {
        return;
    }

    DSM_CC::ModuleTracker* mt = module_trackers[module_id];
    mt->MarkObject(object_key, object_key_length, mark);
}

void DSM_CC::Private::hexdump(uint8_t* buffer, uint32_t length) {
    uint32_t i, j;

    for(i = 0; i < (length / 32) * 32; ++i) {
		if(i % 32 != 0 && i % 16 == 0) {
            printf("  ");
        }
        printf("%02x ", buffer[i]);
        if(i != 0 && i % 32 == 31) {
            printf("  ");
            for(j = i - 31; j <= i; ++j) {
                printf("%c", (buffer[j] < 32 || buffer[j] > 127) ? '.' : buffer[j]);
				if(i - j == 16) {
					printf("  ");
				}
            }
            printf("\n");
        }
    }
    if(length % 32 != 0) {
        for(j = i; j < length; ++j) {
            if(j % 32 != 0 && j % 16 == 0) {
               printf("  ");
            }
            printf("%02x ", buffer[j]);
            
        }
        for(j = length % 32; j < 32; ++j) {
            printf("   ");
        }
		if(length %32 < 16) {
			printf("  ");
		}
        printf("  ");
        for(j = i; j < length; ++j) {
			if(j % 32 != 0 && j % 16 == 0) {
               printf("  ");
            }
            printf("%c", (buffer[j] < 32 || buffer[j] > 127) ? '.' : buffer[j]);
        }
        printf("\n");
    }
}