Mastering add text in davinci resolve 20 essentials

Text Styling and Typography Mastery in DaVinci Resolve 20

Core Typography Tools in the Add Text Module

• Kerning
  Adjusts the spacing between individual characters to refine visual balance. Ideal for custom logos, monogram designs, or tight-fitted text layouts where default spacing disrupts uniformity.

  Example Use Case: Reducing kerning by -0.1px for a serif font (e.g., Garamond) can eliminate uneven gaps between letters like "AV" or "To," improving readability in close-up shots.

• Tracking (Letter Spacing)
  Uniformly increases or decreases space between all characters in a selected text block. Critical for maintaining consistency in long-form captions or dynamic title sequences.

  Optimal Range: For body text, +0.5px to +1.5px tracking enhances legibility without sacrificing density. For display text, –1.0px to +2.0px can create a bold, cinematic effect.

• Leading (Line Spacing)
  Controls vertical spacing between lines of text, directly impacting readability in multi-line elements. Adjustments are measured in points (pt) or as a percentage of font size.

  Formula for Dynamic Leading: Leading = Font Size × 1.2 (minimum) to 1.6 (maximum)
  Example: A 48pt font with 1.4× leading yields 67.2pt line spacing, ideal for subtitles.

• Baseline Shift
  Vertically repositions text relative to its baseline, enabling fine-tuned alignment with surrounding elements (e.g., lowering text to align with a custom icon’s baseline).

  Technical Note: Negative values (e.g., –5pt) lower text; positive values (e.g., +3pt) raise it. Use sparingly to avoid misalignment with descender characters (e.g., "g," "y").

• Text Path and Warping
  Distorts text along custom paths (e.g., circular, wave) or 3D planes, adding depth to motion graphics. The Warping Tool includes:
  • Perspective Warp – Simulates depth via vanishing points.
  • Cylindrical Warp – Wraps text around curved surfaces.
  • Bulge – Applies radial distortion for organic shapes.

Advanced Text Color and Material Effects

• Gradient Fills and Transparency
  Apply multi-color gradients (linear or radial) to text via the Fill tab in the Inspector panel. Transparency controls (via Opacity or Blend Modes) allow for:
  • Glass Text Effect – Combine Screen Blend Mode with a gradient fill (e.g., white-to-transparent) over a background image.
  • Neon Glow – Use Additive Blend Mode with a high-opacity gradient (e.g., cyan-to-magenta) and a Gaussian Blur layer.
  • Textured Overlays – Load a PNG texture (e.g., grunge, metal) into the Fill slot and adjust Opacity to 30–50% for subtle effects.

  Parameter Example for Glass Text:

  Setting	Value
  Fill Gradient	White (100% opacity) → Transparent (0% opacity)
  Blend Mode	Screen
  Opacity	85%
  Background Layer	Urban cityscape (high-contrast)

• Dynamic Color Adjustments with Color Wheels
  The Color Wheels panel (accessed via Right-Click → Edit → Color) enables real-time RGB manipulation for text layers. Key techniques include:
  • RGB Split Effect – Separate red, green, and blue channels into distinct layers, then animate each channel independently for a tri-color dissolve.
  • Luminance-Based Tinting – Adjust the Luma wheel to shift text color based on brightness (e.g., darker text becomes blue-tinted; lighter text turns yellow).
  • Hue Rotation – Rotate the Hue wheel to cycle through color palettes dynamically (e.g., for a "color wheel" title sequence).

  RGB Split Workflow: 1. Duplicate the text layer 3×.
  2. Set each duplicate’s Color Wheel to Red, Green, or Blue channel.
  3. Animate Opacity of each channel (e.g., Red fades in at 0s, Green at 1s, Blue at 2s).
  4. Merge layers in Add mode for a seamless transition.

• Curves for Non-Linear Color Grading
  The Curves panel allows precise control over text color response curves, enabling:
  • Contrast Enhancement – Steepen the curve to increase contrast between light/dark text areas.
  • Vibrance Boost – Apply a S-shaped curve to midtones to amplify color saturation without clipping.
  • Desaturation Selectively – Drag the Master Curve downward in the midtones to mute specific colors (e.g., removing green from a cyan text layer).

Before-and-After Text Styling Transformations

Before (Default Settings):

Parameter	Value
Font	Arial (24pt)
Color	White (#FFFFFF)
Tracking	0px
Leading	30pt (1.25×)
Blend Mode	Normal
Opacity	100%

Result:* Flat, low-contrast text with poor readability against complex backgrounds.

After (Cinematic Styling):

Integrating Text with Visual Effects and Compositing in DaVinci Resolve 20

DaVinci Resolve 20’s Fusion page provides a robust environment for integrating text with visual effects (VFX) and compositing, enabling seamless text insertion into complex scenes. Text layers can be embedded within video compositions, masked for precise isolation, and dynamically animated to interact with live-action footage. This section explores workflows for embedding text in layered video sequences, utilizing chroma keying for composite shots, and applying advanced motion techniques such as parallax effects to enhance realism. Additionally, compatibility with third-party plugins expands Resolve’s text tool capabilities, allowing for specialized effects and workflow optimizations.

The integration of text with VFX and compositing relies on Resolve’s node-based Fusion environment, where text layers function as dynamic elements within a compositing pipeline. Proper masking ensures text remains visually distinct from backgrounds, while chroma keying facilitates text insertion into green-screen footage. Motion graphics techniques, such as depth simulation, further enhance the interaction between text and live-action elements, creating immersive visual narratives.

Embedding Text in Video Layers and Masking Techniques

Text layers in DaVinci Resolve 20 can be embedded within video sequences using Fusion’s node-based compositing tools. The workflow involves creating a text layer in the Fusion page, then merging it with video footage via Merge nodes or Keyers. Masking techniques isolate text from backgrounds, ensuring clean integration into scenes.

Workflow for Text Embedding:
1. Create a Text Layer

Use the Add Text tool in Fusion (under Tools > Text Plus) to generate a text layer.

Adjust font, size, and color in the Inspector panel.

Best Practice: Use vector-based text (e.g., TrueType or OpenType fonts) for scalability without quality loss. 2. Merge with Video Footage

Drag the text layer into the Viewer and connect it to a Merge node (e.g., Merge > Merge).

Place the video layer below the text layer in the node hierarchy to ensure proper stacking.

3. Apply Masking for Isolation

Use Mask nodes (Tools > Mask > Mask Tool) to define the text’s boundaries.

For feathered edges, adjust the Softness parameter in the mask settings.

To invert masks (e.g., for background removal), enable the Invert option.

Technical Note: Masks can be animated using Keyframes in the Animation tab for dynamic effects. 4. Refine with Mattes and Keyers

For luma/color-based masking, use Luma Matte or Color Matte nodes (Tools > Matte).

Apply Chroma Key (Tools > Keyer > Chroma Keyer) if integrating with green-screen footage.

Example Use Case:
A title sequence where text must appear to "float" above a dynamic background (e.g., a cityscape). Masking ensures the text remains crisp while adapting to motion blur or depth-of-field effects in the footage.

Chroma Keying for Text Insertion in Composite Shots

Chroma keying enables text to be inserted into green-screen or blue-screen footage, creating composite shots where text interacts with live-action elements. DaVinci Resolve’s Chroma Keyer tool in Fusion streamlines this process by isolating text from its original background and merging it with a new scene.

Steps for Chroma Key Text Integration:
1. Prepare the Text Layer

Create text in Fusion with a solid background (e.g., white or green) for keying.

Ensure the text’s background color contrasts sharply with the key color (e.g., green screen).

2. Apply Chroma Key to the Text Layer

Insert a Chroma Keyer node (Tools > Keyer > Chroma Keyer) between the text layer and the background footage.

Adjust Key Color, Edge Softness, and Spill Suppression to refine the matte.

Critical Setting: The Screen Balance slider removes color spill from the text edges, improving transparency. 3. Merge with Composite Footage

Connect the chroma-keyed text to a Merge node with the background video layer.

Use Track Mattes (Tools > Matte > Track Matte) if the text must follow camera movement in the footage.

4. Refine with Secondary Keying

For fine-tuned edges, apply a Luma Keyer or Color Keyer to clean up residual artifacts.

Use Blur Matte (Tools > Matte > Blur Matte) to soften edges if needed.

Advanced Technique: Animated Chroma Key Text

Animate the Key Color or Edge Softness parameters over time to create dynamic transitions (e.g., text "melting" into the background).

Example: A news ticker where text appears to dissolve into a green-screen weather map.

Text-Based Motion Graphics and Depth Simulation

Text can be animated to interact with live-action footage through parallax effects, depth simulation, and camera tracking. These techniques create the illusion of text existing in a three-dimensional space, enhancing realism in motion graphics.

Parallax Effects for Text Layers
Parallax involves moving text at a different rate than the background to simulate depth. In Fusion, this is achieved using Transform nodes and Camera Trackers.

1. Set Up a Camera Tracker

Use Camera Tracker (Tools > Camera Tracker > Camera Tracker) on the background footage to generate a 3D camera solve.

Enable 3D Camera in the tracker settings.

2. Apply Parallax to Text

Place the text layer in a 3D Space (Tools > 3D > 3D Space).

Adjust the Z-position of the text to control its depth relative to the camera.

Animate the Position or Rotation of the text using Keyframes to match the camera movement.

3. Add Depth with Shadows and Lighting

Insert a Lighting node (Tools > Lighting > Lighting) to cast shadows from the text onto the background.

Use Displacement Maps (Tools > Displacement > Displacement) for subtle depth distortion.

Example: Floating Text in a Scene
A logo that appears to hover above a character in a live-action shot. By tracking the character’s movement and adjusting the text’s Z-position, the logo maintains a consistent depth relationship.

Depth Simulation with Motion Blur

Enable Motion Blur in the Transform tab of the text layer to match the camera’s movement.

Adjust Shutter Angle to simulate realistic blur based on the shot’s frame rate.

Compatibility of "Add Text" with Third-Party Plugins

Third-party plugins extend DaVinci Resolve’s text tool capabilities, offering specialized effects, workflow enhancements, and compatibility with industry-standard tools. Below is a table outlining compatibility and key features of popular plugins:

Parameter	Value

Plugin	Compatibility with DaVinci Resolve 20	Key Features for Text Integration	Workflow Integration	Example Use Cases
Red Giant Universe	Fully compatible via Fusion; supports OFX plugins	Magic Bullet Looks: Color-grade text for stylized effects (e.g., neon, vintage). Optical Flares: Add lens flares or bokeh effects to text layers. Element 3D: 3D text extrusion and lighting integration. Trapcode Suite: Advanced text animation (e.g., particle-based effects).	OFX plugins load directly in Fusion’s node graph. Supports keyframe animation for dynamic text effects. Works with Resolve’s Fairlight audio tools for synchronized text animations.	Animated title sequences with 3D depth (e.g., sci-fi films). Text with dynamic lighting reacting to scene changes. Particle-based text dissolves for VFX-heavy projects.
Boris FX Continuum	OF Automation and Batch Processing for Text Elements in DaVinci Resolve 20 DaVinci Resolve 20’s Fusion page and node-based workflow enable efficient automation of text operations, reducing manual repetition and streamlining post-production pipelines. By leveraging Fusion’s scripting capabilities, metadata integration, and batch processing tools, editors and motion designers can dynamically generate, modify, and export text elements across multiple clips or projects. This section explores structured methods for automating text tasks, including layer duplication, metadata-driven updates, and cross-software compatibility, while emphasizing time-saving shortcuts and macro configurations. The node-based architecture of Fusion allows text layers to be treated as modular components, enabling batch operations such as duplicating, transforming, or applying effects to multiple instances simultaneously. Additionally, Resolve’s Fusion page supports exporting text layers as separate tracks or sequences, facilitating further refinement in external applications like Adobe After Effects or Premiere Pro. Scripting and expressions further enhance automation by dynamically populating text fields based on file metadata (e.g., timestamps, project names, or custom tags), ensuring consistency across large-scale projects. Batch Duplication and Modification of Text Layers Across Clips Fusion’s node-based workflow simplifies the replication and modification of text layers across multiple clips by treating each text element as an independent node. This approach eliminates the need for manual duplication in the timeline, reducing errors and improving workflow efficiency. To duplicate and modify text layers across clips: 1. Create a Master Text Node: Design the base text layer (e.g., title, subtitle, or lower-third) in Fusion using the Text+ tool. Apply all desired effects (e.g., glow, shadow, motion blur) and animations to this node. 2. Save as a Reusable Template: Export the node as a `.fusion` template (File > Save As > Fusion Template) for future use. This preserves all styling, effects, and animations. 3. Batch Apply via Node Graphs: Open the target clip in Fusion. Drag the saved template into the node graph. Use the Merge node to overlay the template onto the clip. Duplicate the merged node for additional clips (Right-click > Duplicate). Modify text content via the Text+ node’s parameters or replace it entirely by re-linking the node. 4. Use the Batch Processor: Select multiple clips in the Media Pool. Right-click > Batch Process > Custom. Configure the process to apply the pre-built Fusion composition (containing the text node) to each clip. Adjust dynamic parameters (e.g., text content) via metadata or spreadsheet-driven inputs. Key Considerations: For dynamic text updates, use Text+ node parameters tied to metadata (e.g., `ThisComp.sourceFile.name` in expressions). Ensure all clips share a consistent resolution and frame rate to avoid scaling artifacts during batch processing. Test batch operations on a subset of clips first to validate performance and accuracy. Exporting Text Layers as Separate Tracks for External Software Text layers generated in DaVinci Resolve can be exported as standalone tracks or sequences for further editing in applications like After Effects or Premiere Pro. This workflow is particularly useful for integrating text with complex motion graphics or visual effects pipelines. To export text layers for external use: 1. Render Text as a Separate Composition: In Fusion, isolate the text node by routing its output to a Viewer node. Use the Save Image Sequence or Save Movie node to export the text layer as a high-resolution sequence (e.g., PNG or EXR) with an alpha channel. Configure the output to match the project’s resolution and frame rate. 2. Export as an EDL or AAF: Use the Edit Decision List (EDL) or Advanced Authoring Format (AAF) export options (File > Export > EDL/AAF) to generate a timeline description. Include the text layer as a separate track in the EDL/AAF, specifying its source media (e.g., the rendered sequence). Import the EDL/AAF into After Effects or Premiere Pro to reconstruct the timeline with the text layer intact. 3. Use Fusion’s FusionFX Plugin for Premiere Pro: If working with Adobe Premiere Pro, install the FusionFX plugin to directly render Fusion compositions (including text nodes) as native media. Configure the plugin to export text layers as separate clips or nested sequences. 4. Leverage Resolve’s Fairlight Timeline: Add the text layer as a Title or Graphic track in the Fairlight page. Export the timeline as an OMF or AAF file, ensuring the text layer is included as a discrete element. Import the OMF/AAF into After Effects via the File > Import > OMF/AAF option. Best Practices for Cross-Software Compatibility: Maintain consistent naming conventions for text layers to avoid confusion during import. Use lossless formats (e.g., PNG, TIFF, EXR) for text sequences to preserve transparency and quality. For dynamic text (e.g., timestamps), export metadata alongside the media to enable relinking in external software. Test the exported text layer in the target application to verify compatibility with effects and animations. Dynamic Text Updates Using Expressions and Scripts Expressions and scripting in DaVinci Resolve’s Fusion page enable text fields to update dynamically based on metadata, project variables, or external data sources. This capability is invaluable for generating automated captions, dynamic lower-thirds, or metadata-driven titles. Methods for Dynamic Text Updates: 1. Metadata-Driven Text: Use Fusion’s Text+ node to reference metadata fields via expressions. For example: // Display the filename without extension in the text layer ThisComp.sourceFile.name.replace(/\.[^\.]+$/, "") - Common metadata fields include: `ThisComp.sourceFile.name` (filename) `ThisComp.sourceFile.modifyDate` (last modified date) `ThisComp.sourceFile.duration` (clip duration) Custom metadata tags added via Resolve’s Metadata panel. 2. Timestamp-Based Text: Generate dynamic timestamps using Fusion’s Time node or expressions: // Format current time as HH:MM:SS time.toFixed(0).padStart(2, '0') + ":" + (Math.floor(time / 60) % 60).toFixed(0).padStart(2, '0') + ":" + Math.floor(time / 3600).toFixed(0).padStart(2, '0') - Sync timestamps to clip in/out points using: // Display in-point time for a clip ThisComp.layer("Clip1").inPoint.toFixed(2) 3. Scripting with Python or JavaScript: Use Fusion’s Script node to execute custom logic. For example, a Python script can parse a CSV file to populate text layers: import csv with open('data.csv', 'r') as file: reader = csv.DictReader(file) for row in reader: text_node.setValue("text", row["title"]) - Integrate with Resolve’s API via Python to fetch project-wide metadata or automate text generation across multiple clips. 4. Spreadsheet-Driven Text: Import a CSV or Excel file containing text data (e.g., episode titles, speaker names) into Fusion using the Spreadsheet node. Map spreadsheet columns to text node parameters to generate dynamic content. Example Workflow for Metadata-Driven Titles: 1. Add metadata to clips in Resolve (e.g., "Episode 1", "Guest: John Doe") via the Metadata panel. 2. Create a Fusion composition with a Text+ node. 3. Apply an expression to the text field: "Episode " + ThisComp.sourceFile.metadata.get("episode") + "\nGuest: " + ThisComp.sourceFile.metadata.get("guest") 4. Batch process all clips to apply the composition with dynamic text updates. Time-Saving Shortcuts and Macros for Text Operations DaVinci Resolve offers keyboard shortcuts, macros, and custom toolsets to accelerate text-related tasks. Below are categorized shortcuts and macro configurations for efficient layer management, batch renaming, and text editing. Keyboard Shortcuts for Text Layers: Fairlight Page (Timeline): T → Toggle text tool (if enabled in preferences). Ctrl/Cmd + T → Add text track. Alt + Click → Select multiple text layers for batch edits. Shift + Click → Rename selected text layers sequentially (e.g., "Title_1", "Title_2"). Fusion Page (Node Graph): Ctrl/Cmd + D Troubleshooting and Optimization for Text Workflows in DaVinci Resolve 20 Text layers in DaVinci Resolve 20 enhance visual storytelling but often introduce technical challenges, particularly when working with complex typography, multi-camera edits, or high-resolution outputs. Common issues include rendering artifacts, font inconsistencies, synchronization errors, and performance bottlenecks. This section addresses systematic solutions for resolving these problems while optimizing workflows to maintain efficiency and visual fidelity. Best practices for system configuration, proxy management, and collaborative project troubleshooting are also detailed to ensure seamless text integration in professional productions. Common Issues with the "Add Text" Tool and Resolution Methods The "Add Text" tool in DaVinci Resolve 20 may encounter rendering glitches, font substitution errors, or unexpected behavior due to software limitations, incompatible font files, or hardware constraints. Below are categorized solutions with descriptions of error scenarios and their fixes. Rendering Glitches in Text Layers Symptoms: Pixelation, jagged edges, or flickering during playback or rendering, particularly at high resolutions or with complex text effects. Root Causes: Insufficient GPU acceleration for text anti-aliasing. Corrupted or unsupported font files embedded in the project. Overlapping text layers with conflicting transparency settings. - Solutions: Enable GPU Acceleration: Navigate to Preferences > System and ensure GPU Acceleration is set to OpenCL or CUDA (depending on GPU compatibility). For text layers, prioritize Metal on macOS systems. Verify Font Integrity: Replace custom fonts with system-installed alternatives or use `.ttf`/`.otf` files from trusted sources. Resolve may substitute fonts if the original is missing; manually assign fonts via the Text inspector under Font settings. Adjust Render Quality: In the Text inspector, set Anti-aliasing to Subpixel or Multisample for smoother edges. For 4K/8K projects, increase the Resolution slider to match the output scale. Font Rendering Errors Symptoms: Text displays as placeholder boxes (□), incorrect glyphs, or fails to render entirely. Error messages may appear in the Console or Log panel: [ERROR] Font 'CustomScript.ttf' not found. Substituting with 'Arial'. [WARNING] Text layer 'Title' failed to render: Invalid font metrics. Diagnostic Steps: Check the Console (Window > Console) for font-related warnings during project load or rendering. Use the Font Book (macOS) or Character Map (Windows) to verify font availability on the working system. - Corrective Actions: Font Embedding: Ensure fonts are embedded in the project by selecting the text layer, opening the Text inspector, and toggling Embed Font to On. For collaborative projects, distribute font files alongside the `.drp` file. Fallback Fonts: In the Text inspector, define a Fallback Font (e.g., Arial or Helvetica) under Font settings to prevent rendering failures. Reinstall Fonts: If fonts are corrupted, reinstall them via the OS font manager or use a font validation tool like FontForge to repair files. Performance Optimization for High-Resolution Text Layers High-resolution text layers (e.g., 4K/8K) demand significant CPU/GPU resources, leading to lag or dropped frames during editing or rendering. Optimization involves proxy workflows, render quality adjustments, and hardware-level configurations. Proxy Workflows for Text Layers Best Practice: Use proxies to reduce real-time processing load while maintaining editorial flexibility. Steps to Enable Proxies: Select the text layer in the Cut or Edit page. Right-click and choose Generate Proxy or Generate Optimized Media. In the Proxy Settings dialog, adjust: Resolution: Set to 50–75% of the original for real-time editing. Frame Rate: Match the project’s frame rate to avoid interpolation artifacts. Quality: Use Medium or High for proxies to balance speed and fidelity. - Proxy Limitations: Proxies do not support dynamic text effects (e.g., animated strokes). Disable Enable Text Animation in the Text inspector before generating proxies. Revert to original media before final rendering by right-clicking the layer and selecting Revert to Original. Render Quality Adjustments Critical Settings: Optimize Render Settings to minimize render times without sacrificing output quality. Key Parameters in Render Settings (Deliver Page): Text Quality: Set Text Rendering to High for final outputs; use Medium for drafts. Resolution: Match the Project Resolution to avoid upscaling artifacts. For variable frame rates, enable VFR Handling under Advanced. GPU Acceleration: Enable GPU Rendering and select the appropriate API (OpenCL, CUDA, or Metal). Test with a short clip to verify stability. - Hardware-Specific Optimizations: NVIDIA GPUs: Use CUDA for GPU acceleration and ensure drivers are updated to the latest version. AMD GPUs: Select OpenCL and install the AMD Adrenalin software suite. macOS: Prefer Metal for native performance; disable OpenCL if experiencing crashes. Troubleshooting Text Layer Synchronization in Multi-Camera Edits Multi-camera projects or collaborative workflows often suffer from desynchronized text layers due to timeline offsets, nested sequence mismatches, or media file path discrepancies. Below are structured approaches to diagnose and resolve synchronization issues. Identifying Synchronization Issues Indicators: Text appears delayed, stutters, or misaligns with audio/video in specific camera angles. Common Causes: Timeline Offset: Different cameras may have varying Start Timecodes or Offset settings. Nested Sequences: Text layers in nested timelines may inherit incorrect timebase settings. Media File Path Changes: Relinking media after moving files can disrupt text layer timing. - Diagnostic Workflow: Check Timebase Consistency: In the Project Manager, verify all cameras share the same Frame Rate and Timecode Start. Inspect Layer Properties: Select the text layer and review the Time inspector for Offset or Speed adjustments. Reset to 0% if altered. Validate Media Links: Right-click the project in the Media Pool and select Relink Media to resolve broken file paths. Corrective Measures Align Text Layers Across Cameras: Use the Sync Lock feature (Edit > Sync Lock) to link text layers to a reference camera angle. For manual alignment, drag the text layer to the correct position in the timeline and adjust the In/Out Points to match the source clip. Collaborative Project Workflow: Version Control: Use Project Archives (File > Archive Project) to track changes and restore previous states if synchronization breaks. Shared Media Folders: Store all text assets (fonts, graphics) in a centralized location accessible to all collaborators. System Requirements and Best Practices for Smooth Text Rendering Optimal text rendering in DaVinci Resolve 20 depends on hardware specifications, software configurations, and workflow discipline. The following table summarizes essential requirements and best practices to mitigate performance issues. < From foundational text layer customization to integrating advanced motion graphics and troubleshooting performance bottlenecks, DaVinci Resolve 20’s Add Text tool unlocks a spectrum of creative and technical solutions. The ability to automate repetitive tasks, synchronize animations with audio waveforms, and export text elements for external software underscores its role as a cornerstone in contemporary video editing. By leveraging these insights, professionals can refine their workflows, ensuring polished typography that aligns with both artistic vision and production deadlines. Category Minimum Requirements Recommended Requirements Best Practices Hardware Quad-core CPU (64-bit) 8GB RAM Dedicated GPU (2GB VRAM) 1TB HDD (7200 RPM) 8+ core CPU (Intel i7/i9 or AMD Ryzen 7/9) 32GB+ RAM Dedicated GPU (NVIDIA RTX 30xx/40xx or AMD Radeon Pro W6000) NVMe SSD (1TB+)