changed config setting

Signed-off-by: Xiyue Yu <xiyue@google.com>

Author: capri-xiyue

pkg/epp/framework/plugins/requestcontrol/dataproducer/tokenizer/README.md

@@ -76,20 +76,20 @@ apply to every video in the request.
 | ------------------------------- | --------------- | ----------------------------------------------- |
 | `x-llm-d-video-duration-seconds`| float seconds   | Video length; overrides `defaultDuration`.      |
 | `x-llm-d-video-resolution`      | `WIDTHxHEIGHT`  | Frame resolution; overrides `defaultResolution`.|
-| `x-llm-d-video-fps`             | float           | Source frame rate; overrides `frames.defaultSourceFPS` (strided mode). |
+| `x-llm-d-video-fps`             | float           | Source frame rate; overrides `frames.strided.defaultSourceFPS` (strided mode). |
 
 | Parameter                             | Default   | Description                                                                     |
 | ------------------------------------- | --------- | ------------------------------------------------------------------------------- |
 | `estimate.video.tokensPerFrame.mode`  | `dynamic` | `dynamic` (width×height/factor) or `static` (a constant per-frame count).       |
-| `estimate.video.tokensPerFrame.factor`| `1024`    | Dynamic-mode pixels-per-placeholder-token divisor.                              |
-| `estimate.video.tokensPerFrame.staticToken` | –   | Static-mode per-frame placeholder count.                                        |
-| `estimate.video.frames.mode`          | `sampled` | `sampled` (clamp(duration×sampleFPS, minFrames, maxFrames) / temporalPatchSize) or `strided` (min(duration×defaultSourceFPS/frameStride, maxFrames)). |
-| `estimate.video.frames.sampleFPS`     | `1`       | Sampled-mode sampling rate.                                                      |
-| `estimate.video.frames.minFrames`     | –         | Sampled-mode frame floor (0 = none). Models a processor's minimum sampled frames. |
-| `estimate.video.frames.temporalPatchSize` | –     | Sampled-mode: merge every N sampled frames into one token group (qwen3-vl = 2; <2 = no merge). |
-| `estimate.video.frames.defaultSourceFPS` | `24`   | Strided-mode source frame rate; fallback for the `x-llm-d-video-fps` header.     |
-| `estimate.video.frames.frameStride`   | `1`       | Strided-mode divisor: keep every Nth source frame.                              |
+| `estimate.video.tokensPerFrame.dynamic.factor`| `1024` | Dynamic-mode pixels-per-placeholder-token divisor.                            |
+| `estimate.video.tokensPerFrame.static.staticToken` | –  | Static-mode per-frame placeholder count.                                   |
+| `estimate.video.frames.mode`          | `sampled` | `sampled` (clamp(duration×sampleFPS, minFrames, maxFrames) / temporalPatchSize) or `strided` (clamp(duration×defaultSourceFPS/frameStride, minFrames, maxFrames)). |
+| `estimate.video.frames.minFrames`     | –         | Sampled/strided frame floor (0 = none). Models a processor's minimum frames.     |
 | `estimate.video.frames.maxFrames`     | –         | Sampled/strided frame cap (0 = uncapped).                                        |
+| `estimate.video.frames.sampled.sampleFPS`     | `1`       | Sampled-mode sampling rate.                                              |
+| `estimate.video.frames.sampled.temporalPatchSize` | –     | Sampled-mode: merge every N sampled frames into one token group (qwen3-vl = 2; <2 = no merge). |
+| `estimate.video.frames.strided.defaultSourceFPS` | `24`   | Strided-mode source frame rate; fallback for the `x-llm-d-video-fps` header.  |
+| `estimate.video.frames.strided.frameStride`   | `1`       | Strided-mode divisor: keep every Nth source frame.                       |
 | `estimate.video.defaultResolution`    | 640×360   | Per-frame resolution for dynamic tokens-per-frame; fallback for the `x-llm-d-video-resolution` header. |
 | `estimate.video.defaultDuration`      | `10`      | Video length in seconds for frame counting; fallback for the `x-llm-d-video-duration-seconds` header. |
 | `estimate.video.maxVideoTokens`       | –         | Overall placeholder cap for a video (0 = uncapped).                            |

pkg/epp/framework/plugins/requestcontrol/dataproducer/tokenizer/estimate_live_test.go

@@ -70,8 +70,8 @@ var qwen3vlVideoCase = videoModelCase{
 	name:  "qwen3vl",
 	model: "Qwen/Qwen3-VL-30B-A3B-Instruct",
 	cfg: &estimateConfig{Video: &videoEstimateConfig{
-		Frames:         &framesConfig{Mode: videoFramesModeSampled, SampleFPS: 2, MinFrames: 4, TemporalPatchSize: 2},
-		TokensPerFrame: &tokensPerFrameConfig{Mode: videoTPFModeDynamic, Factor: 32 * 32},
+		Frames:         &framesConfig{Mode: videoFramesModeSampled, MinFrames: 4, Sampled: &framesSampledMode{SampleFPS: 2, TemporalPatchSize: 2}},
+		TokensPerFrame: &tokensPerFrameConfig{Mode: videoTPFModeDynamic, Dynamic: &tokensPerFrameDynamicMode{Factor: 32 * 32}},
 		MaxVideoTokens: 12288,
 	}},
 }
@@ -86,8 +86,8 @@ var gemma4VideoCase = videoModelCase{
 	name:  "gemma4",
 	model: "google/gemma-4-31B-it",
 	cfg: &estimateConfig{Video: &videoEstimateConfig{
-		Frames:         &framesConfig{Mode: videoFramesModeStrided, FrameStride: 4, MaxFrames: 8},
-		TokensPerFrame: &tokensPerFrameConfig{Mode: videoTPFModeStatic, StaticToken: 296},
+		Frames:         &framesConfig{Mode: videoFramesModeStrided, MaxFrames: 8, Strided: &framesStridedMode{FrameStride: 4}},
+		TokensPerFrame: &tokensPerFrameConfig{Mode: videoTPFModeStatic, Static: &tokensPerFrameStaticMode{StaticToken: 296}},
 	}},
 }
 

pkg/epp/framework/plugins/requestcontrol/dataproducer/tokenizer/estimate_test.go

@@ -243,7 +243,7 @@ func TestVideoEstimator_Default(t *testing.T) {
 // per-frame count.
 func TestVideoEstimator_StaticTokensPerFrame(t *testing.T) {
 	b := estimateBackend{vid: newVideoEstimator(&estimateConfig{Video: &videoEstimateConfig{
-		TokensPerFrame: &tokensPerFrameConfig{Mode: videoTPFModeStatic, StaticToken: 100},
+		TokensPerFrame: &tokensPerFrameConfig{Mode: videoTPFModeStatic, Static: &tokensPerFrameStaticMode{StaticToken: 100}},
 	}})}
 	tp, err := b.produce(context.Background(), chatVideoBody("https://example.com/clip.mp4"))
 	require.NoError(t, err)
@@ -255,7 +255,7 @@ func TestVideoEstimator_StaticTokensPerFrame(t *testing.T) {
 // per-frame count for the default resolution.
 func TestVideoEstimator_DynamicFactor(t *testing.T) {
 	b := estimateBackend{vid: newVideoEstimator(&estimateConfig{Video: &videoEstimateConfig{
-		TokensPerFrame: &tokensPerFrameConfig{Mode: videoTPFModeDynamic, Factor: 2048},
+		TokensPerFrame: &tokensPerFrameConfig{Mode: videoTPFModeDynamic, Dynamic: &tokensPerFrameDynamicMode{Factor: 2048}},
 	}})}
 	tp, err := b.produce(context.Background(), chatVideoBody("https://example.com/clip.mp4"))
 	require.NoError(t, err)
@@ -269,8 +269,8 @@ func TestVideoEstimator_DynamicFactor(t *testing.T) {
 func TestVideoEstimator_SampledFrames(t *testing.T) {
 	b := estimateBackend{vid: newVideoEstimator(&estimateConfig{Video: &videoEstimateConfig{
 		DefaultDuration: 8,
-		Frames:          &framesConfig{Mode: videoFramesModeSampled, SampleFPS: 2},
-		TokensPerFrame:  &tokensPerFrameConfig{Mode: videoTPFModeStatic, StaticToken: 10},
+		Frames:          &framesConfig{Mode: videoFramesModeSampled, Sampled: &framesSampledMode{SampleFPS: 2}},
+		TokensPerFrame:  &tokensPerFrameConfig{Mode: videoTPFModeStatic, Static: &tokensPerFrameStaticMode{StaticToken: 10}},
 	}})}
 	tp, err := b.produce(context.Background(), chatVideoBody("https://example.com/clip.mp4"))
 	require.NoError(t, err)
@@ -282,15 +282,29 @@ func TestVideoEstimator_SampledFrames(t *testing.T) {
 func TestVideoEstimator_StridedFramesCapped(t *testing.T) {
 	b := estimateBackend{vid: newVideoEstimator(&estimateConfig{Video: &videoEstimateConfig{
 		DefaultDuration: 10,
-		Frames:          &framesConfig{Mode: videoFramesModeStrided, DefaultSourceFPS: 24, FrameStride: 4, MaxFrames: 16},
-		TokensPerFrame:  &tokensPerFrameConfig{Mode: videoTPFModeStatic, StaticToken: 100},
+		Frames:          &framesConfig{Mode: videoFramesModeStrided, MaxFrames: 16, Strided: &framesStridedMode{DefaultSourceFPS: 24, FrameStride: 4}},
+		TokensPerFrame:  &tokensPerFrameConfig{Mode: videoTPFModeStatic, Static: &tokensPerFrameStaticMode{StaticToken: 100}},
 	}})}
 	tp, err := b.produce(context.Background(), chatVideoBody("https://example.com/clip.mp4"))
 	require.NoError(t, err)
 	// duration*sourceFPS/stride = 10*24/4 = 60, capped to 16; 16*100 tokens.
 	assert.Equal(t, 16*100, tp.MultiModalFeatures[0].Length, "strided-frames video length")
 }
 
+// TestVideoEstimator_StridedFramesFloored asserts strided frames apply the
+// minFrames floor when the strided count falls below it.
+func TestVideoEstimator_StridedFramesFloored(t *testing.T) {
+	b := estimateBackend{vid: newVideoEstimator(&estimateConfig{Video: &videoEstimateConfig{
+		DefaultDuration: 1,
+		Frames:          &framesConfig{Mode: videoFramesModeStrided, MinFrames: 8, Strided: &framesStridedMode{DefaultSourceFPS: 24, FrameStride: 4}},
+		TokensPerFrame:  &tokensPerFrameConfig{Mode: videoTPFModeStatic, Static: &tokensPerFrameStaticMode{StaticToken: 100}},
+	}})}
+	tp, err := b.produce(context.Background(), chatVideoBody("https://example.com/clip.mp4"))
+	require.NoError(t, err)
+	// duration*sourceFPS/stride = 1*24/4 = 6, floored to 8; 8*100 tokens.
+	assert.Equal(t, 8*100, tp.MultiModalFeatures[0].Length, "strided-frames floored video length")
+}
+
 // TestVideoEstimator_MaxVideoTokens asserts the overall cap bounds the total
 // placeholder count.
 func TestVideoEstimator_MaxVideoTokens(t *testing.T) {
@@ -309,8 +323,8 @@ func TestVideoEstimator_Qwen3AndGemma4(t *testing.T) {
 	qwen3 := estimateBackend{vid: newVideoEstimator(&estimateConfig{Video: &videoEstimateConfig{
 		DefaultResolution: &resolution{Width: 640, Height: 480},
 		DefaultDuration:   10,
-		TokensPerFrame:    &tokensPerFrameConfig{Mode: videoTPFModeDynamic, Factor: 1024},
-		Frames:            &framesConfig{Mode: videoFramesModeSampled, SampleFPS: 2},
+		TokensPerFrame:    &tokensPerFrameConfig{Mode: videoTPFModeDynamic, Dynamic: &tokensPerFrameDynamicMode{Factor: 1024}},
+		Frames:            &framesConfig{Mode: videoFramesModeSampled, Sampled: &framesSampledMode{SampleFPS: 2}},
 		MaxVideoTokens:    100000,
 	}})}
 	tp, err := qwen3.produce(context.Background(), chatVideoBody("https://example.com/clip.mp4"))
@@ -320,8 +334,8 @@ func TestVideoEstimator_Qwen3AndGemma4(t *testing.T) {
 
 	gemma4 := estimateBackend{vid: newVideoEstimator(&estimateConfig{Video: &videoEstimateConfig{
 		DefaultDuration: 10,
-		TokensPerFrame:  &tokensPerFrameConfig{Mode: videoTPFModeStatic, StaticToken: 256},
-		Frames:          &framesConfig{Mode: videoFramesModeStrided, DefaultSourceFPS: 24, FrameStride: 4, MaxFrames: 16},
+		TokensPerFrame:  &tokensPerFrameConfig{Mode: videoTPFModeStatic, Static: &tokensPerFrameStaticMode{StaticToken: 256}},
+		Frames:          &framesConfig{Mode: videoFramesModeStrided, MaxFrames: 16, Strided: &framesStridedMode{DefaultSourceFPS: 24, FrameStride: 4}},
 	}})}
 	tp, err = gemma4.produce(context.Background(), chatVideoBody("https://example.com/clip.mp4"))
 	require.NoError(t, err)
@@ -428,8 +442,8 @@ func TestVideoEstimator_HeaderMetadataOverridesDefaults(t *testing.T) {
 // drive strided frame counting.
 func TestVideoEstimator_HeaderFPSStridedMode(t *testing.T) {
 	b := estimateBackend{vid: newVideoEstimator(&estimateConfig{Video: &videoEstimateConfig{
-		Frames:         &framesConfig{Mode: videoFramesModeStrided, FrameStride: 2},
-		TokensPerFrame: &tokensPerFrameConfig{Mode: videoTPFModeStatic, StaticToken: 1},
+		Frames:         &framesConfig{Mode: videoFramesModeStrided, Strided: &framesStridedMode{FrameStride: 2}},
+		TokensPerFrame: &tokensPerFrameConfig{Mode: videoTPFModeStatic, Static: &tokensPerFrameStaticMode{StaticToken: 1}},
 	}})}
 	// strided frames = int(duration(3)*fps(30))/2 = 45.
 	tp, err := b.produce(videoCtx(videoMetadata{duration: 3, fps: 30}), chatVideoBody("https://cdn.example.com/movie.mp4"))
@@ -441,8 +455,8 @@ func TestVideoEstimator_HeaderFPSStridedMode(t *testing.T) {
 // header duration but not the header source FPS (sampleFPS is authoritative).
 func TestVideoEstimator_SampledIgnoresHeaderFPS(t *testing.T) {
 	b := estimateBackend{vid: newVideoEstimator(&estimateConfig{Video: &videoEstimateConfig{
-		Frames:         &framesConfig{Mode: videoFramesModeSampled, SampleFPS: 2},
-		TokensPerFrame: &tokensPerFrameConfig{Mode: videoTPFModeStatic, StaticToken: 1},
+		Frames:         &framesConfig{Mode: videoFramesModeSampled, Sampled: &framesSampledMode{SampleFPS: 2}},
+		TokensPerFrame: &tokensPerFrameConfig{Mode: videoTPFModeStatic, Static: &tokensPerFrameStaticMode{StaticToken: 1}},
 	}})}
 	// Same 3s duration, different source fps: both must yield 3*2 = 6.
 	fps30, err := b.produce(videoCtx(videoMetadata{duration: 3, fps: 30}), chatVideoBody("https://example.com/clip.mp4"))
@@ -468,8 +482,8 @@ func TestVideoEstimator_NoHeadersUseDefaults(t *testing.T) {
 // isolates the frame-group count.
 func TestVideoEstimator_TemporalMergeAndMinFrames(t *testing.T) {
 	b := estimateBackend{vid: newVideoEstimator(&estimateConfig{Video: &videoEstimateConfig{
-		Frames:         &framesConfig{Mode: videoFramesModeSampled, SampleFPS: 2, MinFrames: 4, TemporalPatchSize: 2},
-		TokensPerFrame: &tokensPerFrameConfig{Mode: videoTPFModeStatic, StaticToken: 1},
+		Frames:         &framesConfig{Mode: videoFramesModeSampled, MinFrames: 4, Sampled: &framesSampledMode{SampleFPS: 2, TemporalPatchSize: 2}},
+		TokensPerFrame: &tokensPerFrameConfig{Mode: videoTPFModeStatic, Static: &tokensPerFrameStaticMode{StaticToken: 1}},
 	}})}
 	// 10s: 10*2 = 20 sampled frames, /2 temporal merge = 10 groups.
 	long, err := b.produce(videoCtx(videoMetadata{duration: 10}), chatVideoBody("https://example.com/clip.mp4"))

pkg/epp/framework/plugins/requestcontrol/dataproducer/tokenizer/mm_estimate.go

@@ -231,17 +231,25 @@ func newVideoEstimator(cfg *estimateConfig) videoEstimator {
 	}
 	if vid.TokensPerFrame != nil {
 		est.tpfMode = vid.TokensPerFrame.Mode
-		est.factor = vid.TokensPerFrame.Factor
-		est.staticToken = vid.TokensPerFrame.StaticToken
+		if vid.TokensPerFrame.Dynamic != nil {
+			est.factor = vid.TokensPerFrame.Dynamic.Factor
+		}
+		if vid.TokensPerFrame.Static != nil {
+			est.staticToken = vid.TokensPerFrame.Static.StaticToken
+		}
 	}
 	if vid.Frames != nil {
 		est.framesMode = vid.Frames.Mode
-		est.sampleFPS = vid.Frames.SampleFPS
-		est.sourceFPS = vid.Frames.DefaultSourceFPS
-		est.frameStride = vid.Frames.FrameStride
-		est.maxFrames = vid.Frames.MaxFrames
 		est.minFrames = vid.Frames.MinFrames
-		est.temporalPatchSize = vid.Frames.TemporalPatchSize
+		est.maxFrames = vid.Frames.MaxFrames
+		if vid.Frames.Sampled != nil {
+			est.sampleFPS = vid.Frames.Sampled.SampleFPS
+			est.temporalPatchSize = vid.Frames.Sampled.TemporalPatchSize
+		}
+		if vid.Frames.Strided != nil {
+			est.sourceFPS = vid.Frames.Strided.DefaultSourceFPS
+			est.frameStride = vid.Frames.Strided.FrameStride
+		}
 	}
 	return est
 }
@@ -266,13 +274,13 @@ func (e videoEstimator) placeholderCount(ctx context.Context, meta videoMetadata
 	return tokens
 }
 
-// frameCount returns the number of frame token-groups. Sampled mode samples
-// duration*sampleFPS frames, clamps to [minFrames, maxFrames], then merges every
-// temporalPatchSize frames into one group (models e.g. qwen3-vl, which samples
-// ~2fps and merges frame pairs). Strided mode takes
-// min(duration*sourceFPS/frameStride, maxFrames). A header-provided duration and
-// source FPS take precedence over configuration. sampleFPS is a model sampling
-// rate, not a source property, so it is never overridden.
+// frameCount returns the number of frame token-groups. Both modes clamp the raw
+// count to [minFrames, maxFrames]. Sampled mode samples duration*sampleFPS
+// frames, then merges every temporalPatchSize frames into one group (models e.g.
+// qwen3-vl, which samples ~2fps and merges frame pairs). Strided mode takes
+// duration*sourceFPS/frameStride. A header-provided duration and source FPS take
+// precedence over configuration. sampleFPS is a model sampling rate, not a source
+// property, so it is never overridden.
 func (e videoEstimator) frameCount(meta videoMetadata) int {
 	duration := meta.duration
 	if duration <= 0 {
@@ -294,6 +302,9 @@ func (e videoEstimator) frameCount(meta videoMetadata) int {
 			stride = 1
 		}
 		n := int(duration*fps) / stride
+		if e.minFrames > 0 && n < e.minFrames {
+			n = e.minFrames
+		}
 		if e.maxFrames > 0 && n > e.maxFrames {
 			n = e.maxFrames
 		}

pkg/epp/framework/plugins/requestcontrol/dataproducer/tokenizer/tokenizer.go

@@ -144,32 +144,58 @@ type videoEstimateConfig struct {
 type tokensPerFrameConfig struct {
 	// Mode selects "dynamic" (width*height/factor) or "static" (a constant count).
 	Mode string `json:"mode,omitempty"`
+	// Static configures the static (constant per-frame) mode.
+	Static *tokensPerFrameStaticMode `json:"static,omitempty"`
+	// Dynamic configures the dynamic (pixels/factor) mode.
+	Dynamic *tokensPerFrameDynamicMode `json:"dynamic,omitempty"`
+}
+
+// tokensPerFrameStaticMode is the static-mode parameter.
+type tokensPerFrameStaticMode struct {
+	// StaticToken is the per-frame placeholder count.
+	StaticToken int `json:"staticToken,omitempty"`
+}
+
+// tokensPerFrameDynamicMode is the dynamic-mode parameter.
+type tokensPerFrameDynamicMode struct {
 	// Factor maps a frame's pixels to placeholder tokens (width*height/factor).
 	Factor int `json:"factor,omitempty"`
-	// StaticToken is the per-frame placeholder count in static mode.
-	StaticToken int `json:"staticToken,omitempty"`
 }
 
-// framesConfig configures how many frames are counted from a video.
+// framesConfig configures how many frames are counted from a video. MinFrames
+// and MaxFrames clamp the count in both modes; the mode sub-structs hold the
+// mode-specific knobs.
 type framesConfig struct {
 	// Mode selects "sampled" (duration*sampleFPS) or "strided"
-	// (min(duration*sourceFPS/frameStride, maxFrames)).
+	// (duration*sourceFPS/frameStride).
 	Mode string `json:"mode,omitempty"`
-	// SampleFPS is the sampling rate in sampled mode.
+	// MinFrames floors the frame count. Zero means no floor.
+	MinFrames int `json:"minFrames,omitempty"`
+	// MaxFrames caps the frame count. Zero means uncapped.
+	MaxFrames int `json:"maxFrames,omitempty"`
+	// Sampled configures the sampled (duration*sampleFPS) mode.
+	Sampled *framesSampledMode `json:"sampled,omitempty"`
+	// Strided configures the strided (duration*sourceFPS/frameStride) mode.
+	Strided *framesStridedMode `json:"strided,omitempty"`
+}
+
+// framesSampledMode configures the sampled frame-count mode.
+type framesSampledMode struct {
+	// SampleFPS is the sampling rate.
 	SampleFPS float64 `json:"sampleFPS,omitempty"`
-	// DefaultSourceFPS is the fallback source frame rate in strided mode, used
-	// when the x-llm-d-video-fps header is absent.
+	// TemporalPatchSize merges every N sampled frames into one token group,
+	// modeling temporal patch merging (e.g. qwen3-vl uses 2). Values < 2 apply
+	// no merging.
+	TemporalPatchSize int `json:"temporalPatchSize,omitempty"`
+}
+
+// framesStridedMode configures the strided frame-count mode.
+type framesStridedMode struct {
+	// DefaultSourceFPS is the fallback source frame rate, used when the
+	// x-llm-d-video-fps header is absent.
 	DefaultSourceFPS float64 `json:"defaultSourceFPS,omitempty"`
-	// FrameStride keeps every Nth source frame in strided mode.
+	// FrameStride keeps every Nth source frame.
 	FrameStride int `json:"frameStride,omitempty"`
-	// MaxFrames caps the sampled/strided frame count. Zero means uncapped.
-	MaxFrames int `json:"maxFrames,omitempty"`
-	// MinFrames floors the sampled frame count (sampled mode). Zero means no floor.
-	MinFrames int `json:"minFrames,omitempty"`
-	// TemporalPatchSize merges every N sampled frames into one token group
-	// (sampled mode), modeling temporal patch merging (e.g. qwen3-vl uses 2).
-	// Values < 2 apply no merging.
-	TemporalPatchSize int `json:"temporalPatchSize,omitempty"`
 }
 
 // PluginFactory is the factory function for the tokenizer plugin.