decide_transfer()

DistributionDecision MayaFlux::Buffers::BufferTokenDistributor::decide_transfer ( const std::shared_ptr< Buffer > &  source, ProcessingToken  src_token, const std::shared_ptr< Buffer > &  target, ProcessingToken  tgt_token  )

staticprivate

Definition at line 244 of file BufferTokenDistributor.cpp.

{
    auto audio_src = std::dynamic_pointer_cast<AudioBuffer>(source);
    auto audio_tgt = std::dynamic_pointer_cast<AudioBuffer>(target);
    auto vk_src = std::dynamic_pointer_cast<VKBuffer>(source);
    auto vk_tgt = std::dynamic_pointer_cast<VKBuffer>(target);
 
    // Pattern: Audio(SAMPLE_RATE|CPU) → VK(GPU) → Audio(SAMPLE_RATE|CPU)
    if (audio_src && audio_tgt && has_sample_rate(src_token) && has_gpu(src_token) && has_sample_rate(tgt_token) && has_cpu(tgt_token)) {
        // This would be Audio→GPU→Audio, which is forbidden
        // But the distribute() call on each would catch this
        // Just prevent if someone tries to route them together
    }
 
    if (!can_transfer(source, src_token, target, tgt_token)) {
        return DistributionDecision {
            .result = DistributionResult::REJECTED,
            .transfer_processor = nullptr,
            .transfer_direction = ProcessingToken::AUDIO_BACKEND,
            .reason = "Transfer not supported between these buffer types and tokens"
        };
    }
 
    std::shared_ptr<TransferProcessor> processor;
    TransferDirection direction = TransferDirection::AUDIO_TO_GPU;
 
    if (audio_src && vk_tgt) {
        direction = TransferDirection::AUDIO_TO_GPU;
        processor = std::make_shared<TransferProcessor>(audio_src, vk_tgt, direction);
    } else if (vk_src && audio_tgt) {
        direction = TransferDirection::GPU_TO_AUDIO;
        processor = std::make_shared<TransferProcessor>(audio_tgt, vk_src, direction);
    } else if (audio_src && audio_tgt) {
        direction = TransferDirection::AUDIO_TO_GPU; // Reuse as "copy" semantics
        processor = std::make_shared<TransferProcessor>();
        processor->connect_audio_to_gpu(audio_src, nullptr); // Placeholder, will be copy
    } else if (vk_src && vk_tgt) {
        direction = TransferDirection::AUDIO_TO_GPU; // Reuse enum, semantically "copy"
        processor = std::make_shared<TransferProcessor>();
    }
 
    if (!processor) {
        return DistributionDecision {
            .result = DistributionResult::REJECTED,
            .transfer_processor = nullptr,
            .transfer_direction = ProcessingToken::AUDIO_BACKEND,
            .reason = "Failed to create transfer processor"
        };
    }
 
    if (audio_tgt) {
        audio_tgt->force_internal_usage(false);
    }
 
    return DistributionDecision {
        .result = DistributionResult::TRANSFER_ONLY,
        .transfer_processor = processor,
        .transfer_direction = tgt_token,
        .reason = "Transfer processor created"
    };
}

References MayaFlux::Buffers::AUDIO_BACKEND, MayaFlux::Buffers::AUDIO_TO_GPU, can_transfer(), MayaFlux::Buffers::GPU_TO_AUDIO, has_cpu(), has_gpu(), has_sample_rate(), MayaFlux::Buffers::REJECTED, MayaFlux::Buffers::DistributionDecision::result, and MayaFlux::Buffers::TRANSFER_ONLY.

Referenced by distribute_with_transfer().

Here is the call graph for this function:

Here is the caller graph for this function: