acceptodds
Under review as a conference paper at ICLR 2027

SwiftI2V: Efficient High-Resolution Image-to-Video Generation via Conditional Segment-wise Generation

Abstract

High-resolution image-to-video (I2V) generation aims to synthesize realistic temporal dynamics while preserving fine-grained appearance details of the input image. At 2K resolution, it becomes extremely challenging, and existing solutions suffer from various weaknesses: 1) end-to-end models are often prohibitively expensive in memory and latency; 2) cascading low-resolution generation with a generic video super-resolution tends to hallucinate details and drift from input-specific local structures, since the super-resolution stage is not explicitly conditioned on the input image. To this end, we propose SwiftI2V, an efficient framework tailored for high-resolution I2V. Following the widely used two-stage design, it addresses the efficiency–fidelity dilemma by first generating a low-resolution motion reference to reduce token costs and ease the modeling burden, then performing a strongly image-conditioned 2K synthesis guided by the motion to recover input-faithful details with controlled overhead. Specifically, to make generation more scalable, SwiftI2V introduces Conditional Segment-wise Generation (CSG) to synthesize videos segment-by-segment with a bounded per-step token budget, and adopts bidirectional contextual interaction within each segment to improve cross-segment coherence and input fidelity. On VBench-I2V at 2K resolution, SwiftI2V achieves performance comparable to end-to-end baselines while reducing total GPU-time by 202x. Particularly, it enables practical 2K I2V generation on a single datacenter GPU (e.g. H800) or consumer GPU (e.g. RTX 4090).

Primary area:
generative models
Keywords:
High Resolution I2V

Reviews

Among:
Shape:
1234this paper, Top 49%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.33 over 3 reviews, above 51% of the others.
Reviewer_rfJuOpenReview ↗
Rating
3
Confidence
4
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

SwiftI2V tackles a practical problem: generating high-resolution image-to-video results without the cost of running one model over the full 2K sequence. It uses a low-resolution stage to generate a motion reference, then a high-resolution stage conditioned on that reference and the input image. Its CSG strategy generates short temporal segments with a bounded context window.

Critical strengths
  • High-resolution generation has become increasingly important in the field of video generation. Higher resolution requires more computation and memory, so efficiency and visual quality are difficult to improve together. The authors address both in a single system: the first stage handles motion at low resolution, and the second generates high-resolution detail using both the input image and the motion reference. This is a reasonable design for efficient generation, and the transition training is a practical attempt to account for artifacts passed between the stages.
  • CSG has a clear practical purpose. Processing a bounded temporal window gives the second stage a way to control memory use as video length grows. The bidirectional interaction within the window is a plausible choice for maintaining alignment with the input and nearby frames. The ablation against a causal version, along with the longer-video scaling results, helps show what this design contributes.
  • The paper includes benchmark and human ratings, component ablations, analysis of segment boundaries, scaling to longer videos, and a run on an RTX 4090.
Critical weaknesses
  • The related-work discussion omits several relevant HR video generation papers: UltraGen and T3-Video, which explore native high-resolution generation with hierarchical attention; PixelWizard, which uses a compact anchor to guide 2K/4K detail synthesis; and Ultra Flash, which targets real-time streaming generation at 2K.
  • More information about dataset sizes and filtering, baseline inference settings, and what is included in the timing measurements would also help. There is a small resolution discrepancy to clarify: the default output is listed as 2560 × 1408, while the VAE reconstruction experiment uses 2560 × 1440.
  • The human study reports 150 ratings per method and dimension, but not the number of raters, how samples were assigned and randomized, or how much the ratings varied. Those details would help readers judge how strong the human-study result is.
Questions for authors
  • How are text prompts used in each stage, and do all baselines receive the same prompts and input images?
  • Can you provide more detail on the human-study protocol and uncertainty?
  • How does SwiftI2V differ from other related high-resolution anchor-guided or streaming methods?
3 comments

We thank the reviewer for the positive and detailed feedback.

W1 & Q3. Related work and differences. We have added and discussed these four papers.

  • UltraGen, T3-Video: native HR generation with hierarchical/multi-scale sparse window attention; each denoising step still processes all tokens. UltraGen (T2V) uses spatial windows; T3-Video uses spatio-temporal windows and has an I2V version.
  • PixelWizard: two-stage; it first generates a compact LR anchor, then synthesizes 2K/4K details via feature injection; its experiments are text-conditioned, and its Stage II processes the whole video at once.
  • Ultra Flash: a real-time streaming cascade (LR autoregressive generation, latent upsampling, generative SR), text-conditioned and up to 2K; its SR stage uses causal attention with a read-only KV cache.

SwiftI2V differs in two respects. (i) Every fixed-size window contains the user's HR input image as an appearance anchor and follows the global Stage I motion reference; none of the above methods keeps a persistent HR image condition (e.g., Ultra Flash conditions on text and LR latents). (ii) History blocks interact bidirectionally with the current segment at every denoising step, but only the current segment is updated, so per-step tokens are bounded and output is incremental; in contrast, the history in FlashVSR and Ultra Flash is read-only, and UltraGen, T3-Video and PixelWizard process the whole video at every step.

W2. Implementation details. Data. Stage I: a 360P LoRA trained for 20K steps on about 10K OpenViD-HD clips. Stage II: full DiT fine-tuning, first for one epoch on 1080P videos from the same pool, then for 10K steps on a subset of UltraVideo (about 40K 2K clips); the first 7K steps use real videos only, and the last 3K steps mix in about 2K stage-transition synthesized samples at a ratio of 7:3 (synthesized:downsampled). Both datasets are already quality-curated, and we only filter by resolution (at least the training resolution) and duration (at least 81 frames). Training uses 8 H800 GPUs with a per-GPU batch size of 2 for Stage I and 1 for Stage II.

Baselines. All baselines use official code, weights and default sampling settings, with outputs at 2560×1408 and the same input images and prompts; the VSR baselines (DiffVSR, Stream-DiffVSR, FlashVSR-v1.1) perform 4× super-resolution on the same Stage I 360P output. Sampling steps are 50 for CineScale and DiffVSR, 40+3 for LTX-2 (half-resolution generation, then latent upsampling and refinement), 4 for Stream-DiffVSR and 1 for FlashVSR. CineScale runs out of memory on a single H800 at 2K with 81 frames, so Tab. 3 reports its minimum runnable configuration (4 GPUs).

Timing. All methods in Tab. 3 follow the same protocol: after one full warm-up run (which also loads the models), each timed run reloads the models and covers the whole process up to the final 2K video (both stages for SwiftI2V; Stage I plus SR for the VSR pipelines; the full pipeline for CineScale and LTX-2). GPU time = #GPUs × time.

Resolution. The model requires sizes in multiples of 16, so the 360P Stage I uses 640×352 and Stage II outputs 4× that size, i.e., 2560×1408. The VAE experiment bypasses the two-stage pipeline, so it uses the standard 2K resolution of 2560×1440 to measure VAE reconstruction of 2K details.

W3 & Q2. Human study. Fifteen randomly recruited volunteers (a few researchers, mostly non-experts) rated independently. We randomly sampled 20 cases from scenes where all methods have outputs, and each volunteer was randomly assigned 10 cases, yielding 150 ratings per method and dimension. In each case, the six videos are anonymized and randomly ordered, and raters score each from 1 to 3 on four dimensions against the HR input image (per-level criteria in App. B.4). Mean±std of each method:

Mean±stdOverallFidelityDetailTemporal
SwiftI2V2.69±0.542.90±0.302.59±0.612.89±0.32
FlashVSR2.53±0.572.83±0.412.41±0.612.80±0.43
CineScale1.93±0.852.39±0.792.41±0.722.37±0.80
DiffVSR2.06±0.662.73±0.522.12±0.632.11±0.86
Stream-DiffVSR1.83±0.662.75±0.511.69±0.642.32±0.79
LTX-21.21±0.452.17±0.891.96±0.791.69±0.80

Q1. Prompts. All methods use the official VBench-I2V prompts and the same input images. Both stages of SwiftI2V use the same prompt: Stage I takes the downsampled input image and the prompt; Stage II encodes the prompt with the frozen text encoder for the DiT. CineScale and LTX-2 take the same input image and prompt; the VSR baselines take the same Stage I output, which is generated from the same input image and prompt.

Revisions. Related work: the four papers above; Sec. 3.2: the comparison above; App. B.1–B.3: data, prompts, resolution, baseline settings; App. C.8: VAE resolution; Tab. 3 caption and App. B.3: timing protocol; App. B.4: user-study protocol and rating criteria.

I appreciate the authors’ response and will maintain my positive rating.

Thank you for your positive assessment and constructive feedback, which helped improve the revised paper. We appreciate your support.

Reviewer_3P84OpenReview ↗
Rating
2
Confidence
4
Informativeness
1
Presentation
2
Soundness
1
Read review
Paper summary

This paper raised a framework for image-to-video generation, specialized in 2K resolution. It also introduces a conditional segment-wise generation module to bound the token budget. It is evaluated on VBench-I2V benchmark and analysed on runtime and memory consumption.

Critical strengths

The structure of writing is clear. The arrangement of figures and text is easy to read.

Critical weaknesses
  1. Insufficient novelty in model architecture. As is acknowledged in the paper that the two-stage decomposition is widely used in video generation, the novelty lies only in CSG. However, the ablations do not contain how this module would constitute an improvement beyond existing conditionning and widowed generation methods.
  2. No performance improvement. Table2 shows this methods cannot beat the baselines on a public benchmark. Although it has modest advantage on human study, there are literally no details of the candidates involved or the process of the study. Overall, the effectiveness of the method is not proven.
Questions for authors

Could you provide the full protocol of human study? For example, what is the number and recuitment of participants, and what is the number and selection of evaluated video pairs.

3 comments

We thank the reviewer for the comments.

W1. Novelty; existing conditioning and windowed generation. We do not claim the two-stage design as a contribution. Besides CSG (preserving HR input details with low memory usage), our contributions include bidirectional interaction (reducing error accumulation and improving quality) and stage-transition training (training Stage II on data carrying Stage I artifacts, improving quality).

Windowed generation. The two ablations in Tab. 4 emulate two existing types of approaches:

  • w/o bi-inter keeps the same window but uses a causal mask with a KV cache, as in AR streaming methods (CausVid, HiStream). With the same backbone and training budget, Total drops from 6.424 to 6.392, I2V Subject/Background drop from 0.991/0.998 to 0.989/0.996, and errors accumulate faster (NIQE slope +0.093 vs. +0.050 per segment; App. C.10); it is faster (16s vs. 25s DiT time) but uses more memory (23.2 vs. 20.8GB).
  • w/o CSG is unsegmented full-sequence generation: its Total is lower (6.414 vs. 6.424) and it cannot stream outputs; at 241 frames it needs about 44GB, whereas CSG stays below 24GB (App. C.3).

Conditioning. We read "existing conditioning" as how the second stage is conditioned on the input: LR video only (VSR) vs. a persistent HR image anchor (ours). DiffVSR, Stream-DiffVSR and FlashVSR share our Stage I and differ only in the second stage; their I2V Subject/Background are lower than ours. We further injected the HR image once into FlashVSR as a first-frame condition to test whether HR information alone suffices, but it only reaches 0.9850/0.9905, still below SwiftI2V's 0.9910/0.9975. Thus one-time HR injection does not close the gap, though other adaptations might.

W2. Performance and objective. A practical 2K I2V method must simultaneously be faithful to the input, produce reasonable motion, and have an acceptable cost; all design choices in SwiftI2V target these goals. The VBench Total alone does not reflect this; input fidelity, user preference and practical deployment must be considered jointly. Each baseline has a clear weakness, whereas SwiftI2V achieves a good balance:

  • End-to-end methods (CineScale, LTX-2): SwiftI2V has a higher Total, reduces GPU time by 202× relative to CineScale, and is 1.37× faster than LTX-2. Their I2V Subject is slightly higher, mainly due to much less motion (Dynamic Degree 0.1667/0.0488 vs. 0.3008); on the same subset used to evaluate CineScale, SwiftI2V is in fact higher (App. C.2).
  • FlashVSR: its Total is 0.014 higher, but it is lower on both I2V metrics with highly significant per-sample gaps (SwiftI2V wins 243/246 on I2V Subject, Wilcoxon, p≈6e-39; 109/109 on I2V Background, p≈1e-19), and its mean user-study scores are lower on all four dimensions. It is 15s faster, but SwiftI2V has a lower peak memory (33.5GB vs. 49.7GB; Stage II needs only 20.8GB and runs on a 24GB GPU, App. C.4).

Therefore, among the tested methods, SwiftI2V offers the best balance of input fidelity, reasonable motion and low cost (Tab. 1): VSR methods are efficient but less faithful to the input, while end-to-end methods are costlier and less dynamic. The user study complements automatic metrics on 2K details (Q1).

Q1. Human study protocol.

  • Participants: 15 randomly recruited volunteers who rated independently; a few are vision/video researchers, and most are non-expert users.
  • Evaluated videos: 20 cases were randomly sampled from scenes where all six methods have outputs (120 videos); each volunteer was randomly assigned 10 cases (60 videos), yielding 150 ratings per method and dimension.
  • Compared methods: SwiftI2V, FlashVSR, CineScale, DiffVSR, Stream-DiffVSR, LTX-2.
  • Presentation: each case shows the HR input image, the prompt, and six anonymized 2560×1408 videos in random order; raters score each video against the HR input (absolute, not pairwise).
  • Rating criteria (1–3, higher is better): Overall Quality; I2V Fidelity (identity, appearance, color, composition); HR Detail (hair, text, texture); Temporal Stability (flicker, jitter, texture popping). For each, 1 = severe issues (e.g., altered subject, heavy blur or flicker), 2 = visible but moderate issues, 3 = no obvious issues; the full per-level definitions are in App. B.4.
Mean±stdOverallFidelityDetailTemporal
SwiftI2V2.69±0.542.90±0.302.59±0.612.89±0.32
FlashVSR2.53±0.572.83±0.412.41±0.612.80±0.43
CineScale1.93±0.852.39±0.792.41±0.722.37±0.80
DiffVSR2.06±0.662.73±0.522.12±0.632.11±0.86
Stream-DiffVSR1.83±0.662.75±0.511.69±0.642.32±0.79
LTX-21.21±0.452.17±0.891.96±0.791.69±0.80

Revisions. Tab. 4 and Sec. 4.4: existing methods each variant emulates; Sec. 4.2: explicit positioning; App. C.12: FlashVSR with HR injection and paired tests; App. B.4: full user-study protocol with rating criteria.

Thank you for the response. My main concerns remain:

  1. Modest improvements. The reported fidelity and human-evaluation gains over the strongest baseline remain modest. Statistical significance does not by itself establish substantial practical improvement, particularly when the overall benchmark score does not improve over FlashVSR.

  2. Potential recruitment bias in the human evaluation. The inclusion of a few vision/video researchers among only 15 volunteers raises concern that recruitment may have relied on a narrow academic network. The recruitment channels and participants’ relationships with the authors are not disclosed, leaving this potential selection bias unaddressed. Together with the limited coverage of 20 cases, this weakens the evidence for the small reported advantages.

  3. Unresolved novelty concerns. The response largely reiterates designs and ablations already presented in the paper. Explaining why CSG, bidirectional interaction, and stage-transition training are useful does not sufficiently establish their novelty relative to existing conditioning and windowed-generation approaches.

I therefore maintain my current rating.

We thank the reviewer for the follow-up and address the three remaining points below.

1. Practical improvement. We agree that statistical significance alone is not sufficient, and we would like to clarify the practical benefits. In I2V applications, users provide a specific HR image and expect its content and fine details to be preserved; this input fidelity is the core requirement of the task. SwiftI2V obtains the highest human ratings among all methods on all four dimensions, with the largest gap on HR Detail (2.59 vs. 2.41 for FlashVSR), the highest I2V Background, and higher I2V scores than all VSR pipelines; its fidelity advantage over FlashVSR holds on nearly every input rather than only on average (App. C.12). It achieves this at comparable overall benchmark quality and with substantially lower cost: 33% lower peak memory than FlashVSR; one GPU instead of four and 202× less GPU time than CineScale; Stage II memory that stays bounded for longer videos (below 24GB at 241 frames, App. C.3); and 2K generation on a single 24GB consumer GPU (App. C.4). Note also that FlashVSR already shares our Stage I, so this comparison isolates only the second stage; against the other baselines, the gaps are large (e.g., Overall 2.69 vs. 1.21–2.06). Taken together, the data and efficiency results show a substantial practical improvement for high-resolution I2V.

2. Recruitment of the human study. We recruited volunteers by posting open invitations in multiple online groups. None of the raters is an author, and they had little prior knowledge of this project. The few vision/video researchers are respondents to these open invitations; most raters are non-experts. In addition, the study is blinded: method names are hidden, the labels are re-shuffled in every case, and each video is rated against the HR input image, so raters cannot identify or favor a particular method. We agree that 20 cases is a limited scale; we therefore use the human study together with the full-benchmark evaluation, and the two lead to consistent conclusions. We will add the recruitment details in the final version.

3. Novelty. We would like to clarify that our contribution lies at the level of the task and the framework, rather than in any single module. First, we identify high-resolution I2V as a setting with requirements distinct from both high-resolution T2V and video super-resolution: the output must reproduce input-specific fine details at 2K while generating plausible motion, at a practical cost. Existing high-resolution video generation mainly targets T2V, and 2K I2V is currently handled either by end-to-end models with prohibitive cost (CineScale needs four GPUs and 5600s per video, Tab. 3) or by generic VSR that does not condition on the input image. Second, we are not aware of a prior framework designed around these requirements, and SwiftI2V is built specifically for them: Stage I models motion at low resolution, and Stage II is formulated as strongly image-conditioned 2K synthesis, in which CSG conditions every bounded window on the HR input image and a whole-video motion reference, so that history only provides temporal continuity, while stage-transition training closes the gap between the two stages. Third, as summarized in point 1, this framework delivers the best input fidelity and human ratings at a fraction of the cost of end-to-end generation, and makes 2K I2V practical on a single datacenter or consumer GPU. We believe this shows that efficient, input-faithful 2K I2V is achievable without end-to-end high-resolution generation, and provides a practical basis for further exploration of this under-explored direction.

We thank the reviewer again for the comments, which helped us clarify the positioning and the human-study protocol in the revision. We hope these clarifications address the remaining concerns, and we would be grateful if the reviewer could take them into account in the final assessment.

Reviewer_CYEEOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
3
Soundness
3
Read review
Paper summary

This work presents SwiftI2V for 2K image-to-video generation to preserve input details while generating realistic motion. It uses a two-stage decoupled framework: low-resolution motion generation followed by 2K refinement with Conditional Segment-wise Generation and stage-transition training. Evaluated on VBench-I2V, it reaches 6.4244 and runs much faster than CineScale, validated by ablations.

Critical strengths

1.The paper tackles the exact pain point of current generative video research: high-resolution (2K) Image-to-Video generation is computationally prohibitive. The authors clearly articulate the efficiency–fidelity dilemma. This is a highly relevant problem with immediate practical value, and solving it at 2K resolution with 81 frames on a single GPU is a non-trivial achievement. 2.The core intuition is highly intuitive and well-supported with the specific designs. For example, dividing the video temporally and using bidirectional interaction looks technical good.

Critical weaknesses

1.The whole proposed method looks more like an engineering pipeline built on top of two existing Wan2.x models, rather than a fundamentally new algorithmic contribution. The two-stage paradigm is standard. The segmentation idea looks much similar to existing windowed attention/autoregressive streaming approaches. 2.Authors choose to report the experimental results on the VBench-I2V at 2K resolution. While the score is almost 0.99 and near the theoretical maximum, I am afraid that the metrics are saturated and fail to highlight the SwiftI2V's effectiveness compared to other existing approaches. Moreover, while the FlashVSR achieves a higher VBench total score (6.4382 vs. SwiftI2V's 6.4244) and a competitive human study score, it takes only 96s (vs SwifitI2V's 111s) with 49.7GB peak memory. This undermines the claim that the proposed complex two-stage generative design is strictly superior to simpler VSR post-processing. 3.The paper's limitations section only discusses real-time performance, deployment complexity and other issues. It lacks a deep analysis of when the method fails. For example, how does the method handle large camera motions or scene changes? 4.As authors claimed in the limitation section, the proposed method use two separate models, which is not suitable for practical deployment. Deploying two large models sequentially requires significant VRAM management.

Questions for authors

See the weakness part.

1 comment

We thank the reviewer for the careful review.

W1. Contribution; vs. windowed AR streaming. We agree the two-stage paradigm is standard and do not claim it as a contribution; FlashVSR and CineScale are likewise built on Wan-series models. Our contribution is making strongly image-conditioned 2K I2V efficient and input-faithful; each component serves this goal:

  • CSG: each fixed-size window holds an HR anchor block, history blocks and current noisy blocks, concatenated with the aligned Stage I motion reference; this preserves HR input details with low memory usage.
  • Bidirectional interaction: blocks within a window attend to each other while only the current segment is updated; this mitigates the error accumulation of AR methods and improves quality.
  • Stage-transition training: Stage II training inputs are synthesized by Stage I, carrying real Stage I artifacts while keeping exact motion correspondence with HR targets.

AR streaming methods (CausVid, MAGI-1, HiStream) use generated blocks as fixed, read-only context. CSG differs in (i) conditioning: every window contains the HR input image and follows a motion reference generated once for the whole video, so Stage II only synthesizes details; (ii) interaction: anchor and history blocks are recomputed with the current segment at every denoising step. The w/o bi-inter ablation (Tab. 4) keeps the same window but uses a causal mask with KV cache, i.e., the AR setting. With the same backbone and training budget, it runs faster (16s vs. 25s DiT time), but its Total drops from 6.424 to 6.392, its I2V Subject/Background also drop, and its NIQE degradation slope is +0.093/segment (vs. +0.050 for ours; App. C.10).

W2. Metric saturation; FlashVSR. At 2K, the gaps are indeed small on some metrics, including the two key I2V metrics, but they are consistent. SwiftI2V has the highest I2V Background among all methods and beats the three VSR pipelines sharing our Stage I on both I2V metrics (Tab. 2). As FlashVSR uses the same Stage I output, we ran a per-sample paired test: SwiftI2V wins on 243/246 samples for I2V Subject (Wilcoxon, p≈6e-39) and on all 109 for I2V Background (p≈1e-19), so the gap is not noise. Our user study (Tab. 2) complements automatic metrics on 2K details: SwiftI2V has the highest mean on all four dimensions (15 raters, 20 cases).

Note that these VSR baselines are also two-stage pipelines: they share our Stage I and differ only in the second stage. Injecting the HR image once into FlashVSR as a first-frame condition only changes its I2V Subject/Background from 0.9845/0.9901 to 0.9850/0.9905 (ours: 0.9910/0.9975); this one-time injection does not close the gap, though other adaptations might. SwiftI2V also uses less memory: peak 33.5GB (in Stage I; Stage II uses 20.8GB) vs. 49.7GB for FlashVSR, while being 15s slower (111s vs. 96s). We do not claim strict superiority over VSR on every metric; rather, at comparable overall quality, SwiftI2V provides stronger I2V fidelity with relatively low memory and acceptable runtime.

W3. Failure analysis. App. A ("Failure Modes", Fig. 6) analyzes failures: motion is generated once by Stage I and Stage II only adds details, so Stage I motion errors persist (e.g., reversed or missing motion). For the two cases raised by the reviewer:

  • Large camera motion: the trajectory comes from Stage I and does not drift across segments. Large camera motion instead affects details: newly revealed content is absent from the input, so the HR anchor cannot inform it, and its details rely on the Stage I reference and model prior. We compared SwiftI2V with FlashVSR (same Stage I) on all 1118 VBench-I2V videos, binned into quintiles by mean RAFT optical-flow magnitude of the Stage I output (camera and object motion). In the largest-motion bin (224 videos), SwiftI2V wins on 222 videos for I2V Subject and 224 for I2V Background, and the gap widens with motion, suggesting Stage II remains effective under large motion.
  • Scene changes: Stage II follows the Stage I reference and neither introduces nor corrects cuts. After a cut, the anchor is unrelated, and Stage II reduces to detail synthesis conditioned on the Stage I reference. VBench-I2V has no hard cuts and I2V models rarely generate them; we state this as a limitation in App. A.

W4. Deploying two models. The 111s in Tab. 3 is end-to-end and includes model loading of both stages. Peak memory is 33.5GB (Stage I) and Stage II needs only 20.8GB, so one H800 suffices without extra memory optimization. On a 24GB RTX 4090, Stage I uses cpu_offload and Stage II runs directly thanks to the bounded memory of CSG (about 380s per 2K, 81-frame video; App. C.4). LR+VSR pipelines also involve two models (49–58GB peak), and the single-model CineScale needs at least 4 H800s at 2K.

Revisions. Sec. 3.2: comparison with AR streaming; Sec. 4.2: explicit claim; App. A: "Failure Modes" with both cases; App. C.12: FlashVSR with HR injection and paired tests.

Comments on the paper

1 comment

Dear Reviewers,

Thank you for your thoughtful reviews and constructive suggestions, which have helped us improve our paper!

We have carefully addressed each of your concerns in our point-by-point responses. We would greatly appreciate it if you could take a moment to review our responses and share your thoughts. If you have any remaining concerns or further questions, please let us know. We would be more than happy to provide further clarifications and engage in additional discussions.

Thank you again for your time and valuable feedback!

Best regards,
The Authors

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.