HarmonyOS开发中的HDR视频：HDR10/HLG/Dolby Vision、HDR渲染管线、色调映射、HDR与SDR兼容、HDR元数据

核心要点：掌握HarmonyOS HDR视频全链路技术，从HDR10/HLG/Dolby Vision标准差异到渲染管线搭建，从色调映射算法到SDR兼容策略，打造极致的HDR视觉体验。

一、背景与动机

你有没有在手机上看过HDR视频？那种亮部细节丰富、暗部层次分明的画面，和普通SDR视频比起来，就像从2D世界进入了3D世界——看过就回不去了。

但HDR视频的开发远比想象中复杂。首先，HDR不是一个标准，而是一堆标准——HDR10、HDR10+、HLG、Dolby Vision，它们各自有不同的元数据格式、色彩空间和传输函数。其次，不是所有设备都支持HDR显示，你需要处理HDR到SDR的色调映射（Tone Mapping），让HDR内容在SDR屏幕上也能正常显示。再者，HDR视频的渲染管线和SDR完全不同，需要正确处理PQ/HLG传输函数、BT.2020色彩空间、10-bit色深等。

HarmonyOS从5.0开始支持HDR视频播放，到6.0更是大幅增强了HDR能力。本文就来把HDR视频开发这件事从头到尾讲清楚。

二、核心原理

2.1 HDR标准对比

flowchart TD
    classDef primary fill:#4FC3F7,stroke:#0288D1,color:#000
    classDef warning fill:#FFB74D,stroke:#F57C00,color:#000
    classDef error fill:#EF5350,stroke:#C62828,color:#fff
    classDef info fill:#81C784,stroke:#388E3C,color:#000
    classDef purple fill:#CE93D8,stroke:#7B1FA2,color:#000

    A[HDR标准]:::primary --> B[HDR10]:::warning
    A --> C[HDR10+]:::info
    A --> D[HLG]:::purple
    A --> E[Dolby Vision]:::error

    B --> B1[静态元数据]:::primary
    B --> B2[PQ传输函数]:::primary
    B --> B3[BT.2020色彩空间]:::primary
    B --> B4[10-bit色深]:::primary
    B --> B5[开放标准/免费]:::primary

    C --> C1[动态元数据]:::info
    C --> C2[逐帧优化]:::info
    C --> C3[三星主导]:::info

    D --> D1[场景参考]:::purple
    D --> D2[向后兼容SDR]:::purple
    D --> D3[广播标准]:::purple
    D --> D4[无元数据依赖]:::purple

    E --> E1[动态元数据RPU]:::error
    E --> E2[12-bit色深]:::error
    E --> E3[杜比专有/授权]:::error
    E --> E4[Profile 5/8]:::error

    style A stroke-width:3px
    style E stroke-width:3px

2.2 HDR渲染管线

flowchart TD
    classDef primary fill:#4FC3F7,stroke:#0288D1,color:#000
    classDef warning fill:#FFB74D,stroke:#F57C00,color:#000
    classDef error fill:#EF5350,stroke:#C62828,color:#fff
    classDef info fill:#81C784,stroke:#388E3C,color:#000
    classDef purple fill:#CE93D8,stroke:#7B1FA2,color:#000

    A[HDR视频输入]:::primary --> B[解码器解码]:::warning
    B --> C{显示能力检测}:::purple

    C -->|HDR显示| D[HDR渲染路径]:::info
    C -->|SDR显示| E[色调映射路径]:::error

    D --> D1[应用PQ/HLG传输函数]:::primary
    D1 --> D2[BT.2020色彩空间]:::primary
    D2 --> D3[HDR元数据应用]:::primary
    D3 --> D4[直接输出到HDR屏幕]:::primary

    E --> E1[色调映射算法]:::warning
    E1 --> E2[BT.2020→BT.709转换]:::warning
    E2 --> E3[10-bit→8-bit量化]:::warning
    E3 --> E4[输出到SDR屏幕]:::warning

    style C stroke-width:3px
    style D stroke-width:3px
    style E stroke-width:3px

2.3 色调映射（Tone Mapping）原理

色调映射是HDR到SDR转换的核心。HDR的亮度范围是0-10000 nits，而SDR只有0-100 nits。直接截断会导致高光过曝、暗部丢失。

常用色调映射算法：

1. Reinhard：简单高效，output = input / (1 + input)，适合实时处理
2. Hable（Uncharted 2）：电影级效果，保留高光细节
3. ACES：电影工业标准，色彩还原最自然
4. BT.2390：广播标准推荐，基于PQ曲线的映射

2.4 HDR元数据

HDR元数据告诉显示器如何正确渲染HDR内容：

• 静态元数据（HDR10）：整个视频使用同一组参数

  • maxDisplayLuminance：最大显示亮度（nits）
  • minDisplayLuminance：最小显示亮度（nits）
  • maxContentLightLevel（MaxCLL）：内容峰值亮度
  • maxFrameAverageLightLevel（MaxFALL）：帧平均峰值亮度

• 动态元数据（HDR10+/Dolby Vision）：每帧可以有不同的参数

  • 逐帧的亮度分析
  • 色调映射参数
  • 饱和度映射参数

三、代码实战

3.1 HDR视频播放与能力检测

播放HDR视频的第一步，是检测设备是否支持HDR显示，并选择正确的渲染路径。

import { media } from '@kit.MediaKit';
import { display } from '@kit.ArkUI';
import { BusinessError } from '@kit.BasicServicesKit';

/**
 * HDR视频播放管理器
 * 自动检测HDR能力，选择最优渲染路径
 */
class HDRVideoPlayer {
  private avPlayer: media.AVPlayer | null = null;
  private isHDRDisplay: boolean = false;
  private hdrCapabilities: HDRCapabilities | null = null;

  /**
   * 初始化HDR播放环境
   * 检测设备HDR显示能力
   */
  async initHDRPlayback(): Promise<void> {
    try {
      // 第一步：检测屏幕HDR能力
      this.hdrCapabilities = await this.detectHDRCapabilities();

      if (this.hdrCapabilities.supported) {
        this.isHDRDisplay = true;
        console.info(`[HDR] 设备支持HDR显示, 支持格式: ${this.hdrCapabilities.formats.join(', ')}`);
        console.info(`[HDR] 峰值亮度: ${this.hdrCapabilities.maxLuminance} nits`);
      } else {
        this.isHDRDisplay = false;
        console.info('[HDR] 设备不支持HDR显示，将使用色调映射');
      }

      // 第二步：创建AVPlayer
      this.avPlayer = await media.createAVPlayer();
      this.setupPlayerListeners();
    } catch (error) {
      const err = error as BusinessError;
      console.error(`[HDR] 初始化失败: ${err.code} - ${err.message}`);
    }
  }

  /**
   * 检测设备HDR显示能力
   */
  private async detectHDRCapabilities(): Promise<HDRCapabilities> {
    const capabilities: HDRCapabilities = {
      supported: false,
      formats: [],
      maxLuminance: 100,
      isDolbyVisionSupported: false,
    };

    try {
      // 获取默认显示器信息
      const defaultDisplay = display.getDefaultDisplaySync();
      const displayInfo = defaultDisplay;

      // 检测HDR支持（通过屏幕属性判断）
      // HarmonyOS 5.0+: 检查display的HDR能力
      if (displayInfo && displayInfo.refreshRate > 0) {
        // 通过系统属性检测HDR支持
        const hdrSupported = this.checkHDRSupport();
        capabilities.supported = hdrSupported;

        if (hdrSupported) {
          capabilities.formats = this.getSupportedHDRFormats();
          capabilities.maxLuminance = this.getPeakLuminance();
          capabilities.isDolbyVisionSupported = this.checkDolbyVisionSupport();
        }
      }
    } catch (error) {
      console.warn('[HDR] 检测HDR能力失败，默认为SDR模式');
    }

    return capabilities;
  }

  /**
   * 检查HDR支持
   */
  private checkHDRSupport(): boolean {
    // 实际项目中通过系统API或设备配置判断
    // 这里提供检测逻辑框架
    try {
      // 方式1：通过AVPlayer的HDR配置检测
      // 方式2：通过display API检测
      // 方式3：通过设备型号白名单
      return true; // 简化示例
    } catch {
      return false;
    }
  }

  /**
   * 获取支持的HDR格式列表
   */
  private getSupportedHDRFormats(): string[] {
    const formats: string[] = [];
    // 根据设备能力返回支持的HDR格式
    formats.push('HDR10');   // 大部分HDR设备都支持
    formats.push('HLG');     // 广播标准
    // Dolby Vision需要授权，部分设备支持
    return formats;
  }

  /**
   * 获取屏幕峰值亮度
   */
  private getPeakLuminance(): number {
    // 不同设备峰值亮度不同
    // 高端手机: 1000-2000 nits
    // 中端手机: 500-800 nits
    // 平板: 400-600 nits
    return 1000; // 简化示例
  }

  /**
   * 检查Dolby Vision支持
   */
  private checkDolbyVisionSupport(): boolean {
    // Dolby Vision需要硬件解码器支持+杜比授权
    return false; // 简化示例
  }

  /**
   * 设置播放器监听
   */
  private setupPlayerListeners(): void {
    if (!this.avPlayer) return;

    // 监听视频尺寸变化（可获取HDR信息）
    this.avPlayer.on('videoSizeChange', (width: number, height: number) => {
      console.info(`[HDR] 视频尺寸: ${width}x${height}`);
    });

    // 监听状态变化
    this.avPlayer.on('stateChange', async (state: string) => {
      if (state === 'prepared') {
        // 准备完成后，检查视频是否为HDR
        await this.checkVideoHDRInfo();
      }
    });
  }

  /**
   * 检查视频的HDR信息
   */
  private async checkVideoHDRInfo(): Promise<void> {
    if (!this.avPlayer) return;

    try {
      // 获取视频的HDR类型
      const hdrType = this.avPlayer.hdrType;
      console.info(`[HDR] 视频HDR类型: ${hdrType}`);

      // 根据HDR类型和显示能力，决定渲染策略
      if (hdrType !== media.HdrType.HDR_NONE && !this.isHDRDisplay) {
        console.info('[HDR] HDR视频在SDR屏幕播放，需要色调映射');
        this.applyToneMapping(hdrType);
      }
    } catch (error) {
      console.warn('[HDR] 获取HDR信息失败');
    }
  }

  /**
   * 应用色调映射
   */
  private applyToneMapping(hdrType: media.HdrType): void {
    // 色调映射策略根据HDR类型选择
    switch (hdrType) {
      case media.HdrType.HDR_VIVID:
        console.info('[HDR] 应用HDR Vivid色调映射');
        break;
      case media.HdrType.HDR10:
        console.info('[HDR] 应用HDR10色调映射');
        break;
      case media.HdrType.HLG:
        console.info('[HDR] 应用HLG色调映射（HLG天然兼容SDR）');
        break;
      default:
        console.info('[HDR] 应用通用色调映射');
        break;
    }
  }

  /**
   * 播放HDR视频
   */
  async playHDRVideo(videoPath: string): Promise<void> {
    if (!this.avPlayer) return;

    try {
      // 配置HDR播放参数
      this.avPlayer.url = videoPath;

      // 如果设备支持HDR，设置HDR渲染模式
      if (this.isHDRDisplay) {
        console.info('[HDR] 使用HDR渲染路径');
      } else {
        console.info('[HDR] 使用SDR渲染路径（带色调映射）');
      }

      await this.avPlayer.play();
    } catch (error) {
      const err = error as BusinessError;
      console.error(`[HDR] 播放失败: ${err.code} - ${err.message}`);
    }
  }

  /**
   * 释放资源
   */
  async release(): Promise<void> {
    if (this.avPlayer) {
      await this.avPlayer.release();
      this.avPlayer = null;
    }
  }
}

/**
 * HDR能力信息
 */
interface HDRCapabilities {
  supported: boolean;               // 是否支持HDR显示
  formats: string[];                // 支持的HDR格式列表
  maxLuminance: number;             // 峰值亮度（nits）
  isDolbyVisionSupported: boolean;  // 是否支持Dolby Vision
}

3.2 色调映射算法实现

当HDR视频在SDR屏幕上播放时，需要进行色调映射。以下是几种常用算法的ArkTS实现。

/**
 * 色调映射算法集合
 * 将HDR高动态范围内容映射到SDR标准动态范围
 */
class ToneMappingAlgorithms {
  /**
   * Reinhard色调映射
   * 最简单高效的算法，适合实时处理
   * 公式: output = input / (1 + input)
   * 
   * @param hdrValue HDR亮度值（0-1归一化）
   * @param whitePoint 白点亮度（可选，默认1.0）
   * @returns SDR亮度值（0-1）
   */
  static reinhard(hdrValue: number, whitePoint: number = 1.0): number {
    // Reinhard扩展公式，支持白点调整
    const mapped = hdrValue * (1 + hdrValue / (whitePoint * whitePoint)) / (1 + hdrValue);
    return Math.min(mapped, 1.0);
  }

  /**
   * Hable（Uncharted 2）色调映射
   * 电影级效果，保留更多高光细节
   * 适合HDR10内容的映射
   * 
   * @param hdrValue HDR亮度值（0-1归一化）
   * @param exposureBias 曝光偏移（默认2.0）
   * @returns SDR亮度值（0-1）
   */
  static hable(hdrValue: number, exposureBias: number = 2.0): number {
    // Hable曲线参数
    const A = 0.22;  // 肩部斜率
    const B = 0.30;  // 线性段起始点
    const C = 0.10;  // 脚部斜率
    const D = 0.20;  // 脚部偏移
    const E = 0.01;  // 脚部高度
    const F = 0.30;  // 肩部高度

    // 应用曝光偏移
    const x = hdrValue * exposureBias;

    // Hable曲线函数
    const curve = (x: number): number => {
      return ((x * (A * x + C * B) + D * E) / (x * (A * x + B) + D * F)) - E / F;
    };

    // 映射并归一化
    const whitePoint = curve(11.2); // 参考白点
    const mapped = curve(x) / whitePoint;
    return Math.min(Math.max(mapped, 0), 1.0);
  }

  /**
   * ACES色调映射
   * 电影工业标准，色彩还原最自然
   * Academy Color Encoding System
   * 
   * @param hdrValue HDR亮度值（0-1归一化）
   * @returns SDR亮度值（0-1）
   */
  static aces(hdrValue: number): number {
    // ACES RRT/ODT拟合曲线
    const a = 2.51;
    const b = 0.03;
    const c = 2.43;
    const d = 0.59;
    const e = 0.14;

    const mapped = (hdrValue * (a * hdrValue + b)) / (hdrValue * (c * hdrValue + d) + e);
    return Math.min(Math.max(mapped, 0), 1.0);
  }

  /**
   * BT.2390色调映射
   * ITU-R广播标准推荐算法
   * 基于PQ曲线，适合HDR10/HLG内容
   * 
   * @param hdrValue HDR亮度值（0-1归一化PQ值）
   * @param luminanceMax 显示器峰值亮度（nits）
   * @param luminanceMin 显示器最低亮度（nits）
   * @param contentMax 内容峰值亮度（nits）
   * @returns SDR亮度值（0-1）
   */
  static bt2390(
    hdrValue: number,
    luminanceMax: number = 100,
    luminanceMin: number = 0.01,
    contentMax: number = 1000
  ): number {
    // 步骤1：PQ到线性的转换
    const linearHDR = this.pqToLinear(hdrValue);

    // 步骤2：归一化到显示亮度范围
    const normalizedMin = Math.max(luminanceMin / luminanceMax, 0.0001);
    const normalizedMax = Math.min(contentMax / luminanceMax, 1.0);

    // 步骤3：应用BT.2390色调映射曲线
    let mapped: number;
    if (linearHDR <= normalizedMin) {
      // 低于最低亮度，直接映射为0
      mapped = 0;
    } else if (linearHDR >= normalizedMax) {
      // 高于内容峰值，映射为1
      mapped = 1.0;
    } else {
      // 中间范围：应用S型曲线
      const p = Math.pow(linearHDR, 1.0 / 2.4);  // 近似gamma
      mapped = Math.pow(p, 2.4);
    }

    return Math.min(Math.max(mapped, 0), 1.0);
  }

  /**
   * PQ（Perceptual Quantizer）到线性的转换
   * ST 2084标准定义的PQ传输函数的逆函数
   * 
   * @param pqValue PQ编码值（0-1）
   * @returns 线性亮度值（0-1，归一化到10000 nits）
   */
  static pqToLinear(pqValue: number): number {
    const m1 = 2610.0 / 16384.0;  // 0.15930175781
    const m2 = 2523.0 / 32.0;     // 78.84375
    const c1 = 3424.0 / 4096.0;   // 0.8359375
    const c2 = 2413.0 / 128.0;    // 18.8515625
    const c3 = 2392.0 / 128.0;    // 18.6875

    // PQ逆函数
    const vp = Math.pow(pqValue, 1.0 / m2);
    const linear = Math.pow(Math.max(vp - c1, 0) / (c2 - c3 * vp), 1.0 / m1);

    return linear;
  }

  /**
   * HLG到线性的转换
   * ARIB STD-B67定义的HLG传输函数
   * HLG在SDR显示上可以直接显示（兼容特性）
   * 
   * @param hlgValue HLG信号值（0-1）
   * @param gamma 显示gamma值（默认1.2）
   * @returns 线性亮度值（0-1）
   */
  static hlgToLinear(hlgValue: number, gamma: number = 1.2): number {
    const a = 0.17883277;
    const b = 0.28466892;
    const c = 0.55991073;

    let linear: number;
    if (hlgValue <= 0.5) {
      // 线性段
      linear = Math.pow(hlgValue, 2) / 3;
    } else {
      // 对数段
      linear = (Math.exp((hlgValue - c) / a) + b) / 12;
    }

    // 应用场景gamma
    return Math.pow(linear, gamma);
  }

  /**
   * 色彩空间转换 BT.2020 → BT.709
   * HDR视频通常使用BT.2020色彩空间，SDR使用BT.709
   * 
   * @param r2020 BT.2020空间的R分量（0-1）
   * @param g2020 BT.2020空间的G分量（0-1）
   * @param b2020 BT.2020空间的B分量（0-1）
   * @returns BT.709空间的[R, G, B]
   */
  static bt2020ToBT709(r2020: number, g2020: number, b2020: number): [number, number, number] {
    // BT.2020 → BT.709 转换矩阵
    // 基于ITU-R BT.2087推荐
    const r709 = 1.6605 * r2020 - 0.5876 * g2020 - 0.0729 * b2020;
    const g709 = -0.1246 * r2020 + 1.1329 * g2020 - 0.0083 * b2020;
    const b709 = -0.0182 * r2020 - 0.1006 * g2020 + 1.1187 * b2020;

    return [
      Math.min(Math.max(r709, 0), 1),
      Math.min(Math.max(g709, 0), 1),
      Math.min(Math.max(b709, 0), 1),
    ];
  }
}

3.3 HDR元数据解析与SDR兼容策略

import { media } from '@kit.MediaKit';
import { fileIo } from '@kit.CoreFileKit';
import { BusinessError } from '@kit.BasicServicesKit';

/**
 * HDR静态元数据（SMPTE ST 2086）
 */
interface HDRStaticMetadata {
  displayPrimaries: [      // 显示器三原色坐标（CIE 1931 xy）
    [number, number],      // 绿色
    [number, number],      // 蓝色
    [number, number],      // 红色
  ];
  whitePoint: [number, number];  // 白点坐标
  maxDisplayLuminance: number;   // 最大显示亮度（nits）
  minDisplayLuminance: number;   // 最小显示亮度（nits）
  maxContentLightLevel: number;  // 内容峰值亮度MaxCLL（nits）
  maxFrameAverageLightLevel: number; // 帧平均峰值亮度MaxFALL（nits）
}

/**
 * HDR内容分析器
 * 解析HDR元数据，制定SDR兼容策略
 */
class HDRContentAnalyzer {
  private staticMetadata: HDRStaticMetadata | null = null;
  private currentHDRType: media.HdrType = media.HdrType.HDR_NONE;

  /**
   * 分析HDR视频内容
   * @param videoPath 视频文件路径
   * @returns HDR分析结果
   */
  async analyzeHDRContent(videoPath: string): Promise<HDRAnalysisResult> {
    const result: HDRAnalysisResult = {
      isHDR: false,
      hdrType: 'SDR',
      peakLuminance: 100,
      recommendedMapping: 'none',
      colorSpace: 'BT.709',
      bitDepth: 8,
    };

    try {
      const avPlayer = await media.createAVPlayer();
      avPlayer.url = videoPath;

      // 等待准备完成
      await new Promise<void>((resolve) => {
        avPlayer.on('stateChange', (state: string) => {
          if (state === 'prepared') {
            resolve();
          }
        });
      });

      // 获取HDR类型
      this.currentHDRType = avPlayer.hdrType;

      switch (this.currentHDRType) {
        case media.HdrType.HDR10:
          result.isHDR = true;
          result.hdrType = 'HDR10';
          result.peakLuminance = 1000;
          result.recommendedMapping = 'bt2390';
          result.colorSpace = 'BT.2020';
          result.bitDepth = 10;
          break;

        case media.HdrType.HDR_VIVID:
          result.isHDR = true;
          result.hdrType = 'HDR Vivid';
          result.peakLuminance = 1000;
          result.recommendedMapping = 'hable';
          result.colorSpace = 'BT.2020';
          result.bitDepth = 10;
          break;

        case media.HdrType.HLG:
          result.isHDR = true;
          result.hdrType = 'HLG';
          result.peakLuminance = 1000;
          result.recommendedMapping = 'hlg_native'; // HLG天然兼容SDR
          result.colorSpace = 'BT.2020';
          result.bitDepth = 10;
          break;

        default:
          result.isHDR = false;
          result.hdrType = 'SDR';
          result.peakLuminance = 100;
          result.recommendedMapping = 'none';
          result.colorSpace = 'BT.709';
          result.bitDepth = 8;
          break;
      }

      await avPlayer.release();
    } catch (error) {
      console.error('[HDRAnalyzer] 分析失败');
    }

    return result;
  }

  /**
   * 制定SDR兼容策略
   * 根据HDR类型和目标显示能力，选择最优映射方案
   * 
   * @param hdrType HDR视频类型
   * @param targetLuminance 目标显示器峰值亮度（nits）
   * @returns 兼容策略
   */
  createSDRCompatibilityStrategy(
    hdrType: media.HdrType,
    targetLuminance: number = 100
  ): SDRCompatibilityStrategy {
    const strategy: SDRCompatibilityStrategy = {
      toneMappingAlgorithm: 'reinhard',
      colorSpaceConversion: true,
      bitDepthReduction: true,
      saturationAdjustment: 1.0,
      brightnessCompensation: 0,
    };

    switch (hdrType) {
      case media.HdrType.HDR10:
        // HDR10使用PQ传输函数，需要完整的色调映射
        strategy.toneMappingAlgorithm = targetLuminance >= 400 ? 'bt2390' : 'hable';
        strategy.colorSpaceConversion = true;
        strategy.saturationAdjustment = 0.9; // 适度降低饱和度防止过饱和
        strategy.brightnessCompensation = 0.1; // 适度提亮暗部
        break;

      case media.HdrType.HLG:
        // HLG天然兼容SDR，但可以优化
        strategy.toneMappingAlgorithm = 'hlg_native';
        strategy.colorSpaceConversion = true;
        strategy.saturationAdjustment = 1.0;
        strategy.brightnessCompensation = 0;
        break;

      case media.HdrType.HDR_VIVID:
        // HDR Vivid需要专用映射
        strategy.toneMappingAlgorithm = 'hable';
        strategy.colorSpaceConversion = true;
        strategy.saturationAdjustment = 0.85;
        strategy.brightnessCompensation = 0.15;
        break;

      default:
        // SDR内容无需映射
        strategy.toneMappingAlgorithm = 'none';
        strategy.colorSpaceConversion = false;
        strategy.bitDepthReduction = false;
        break;
    }

    console.info(`[HDRAnalyzer] SDR兼容策略: 算法=${strategy.toneMappingAlgorithm}, ` +
      `色彩转换=${strategy.colorSpaceConversion}, 饱和度=${strategy.saturationAdjustment}`);

    return strategy;
  }

  /**
   * 解析HDR10静态元数据
   * 从SEI消息中提取ST 2086元数据
   */
  parseHDR10StaticMetadata(data: Uint8Array): HDRStaticMetadata | null {
    try {
      // ST 2086元数据结构（24字节）:
      // 0-7: display_primaries (3组xy坐标，每组4字节)
      // 8-11: white_point (1组xy坐标，4字节)
      // 12-13: max_display_luminance (2字节)
      // 14-15: min_display_luminance (2字节)
      // 16-17: max_content_light_level (2字节，可选)
      // 18-19: max_frame_average_light_level (2字节，可选)

      if (data.length < 16) {
        return null;
      }

      const view = new DataView(data.buffer);

      // 解析三原色坐标（每个值是0-50000的整数，表示0.0000-0.5000）
      const greenX = view.getUint16(0) / 50000;
      const greenY = view.getUint16(2) / 50000;
      const blueX = view.getUint16(4) / 50000;
      const blueY = view.getUint16(6) / 50000;
      const redX = view.getUint16(8) / 50000;
      const redY = view.getUint16(10) / 50000;

      // 白点
      const whiteX = view.getUint16(12) / 50000;
      const whiteY = view.getUint16(14) / 50000;

      // 亮度值
      const maxLuminance = view.getUint16(16); // nits
      const minLuminance = view.getUint16(18) / 10000; // 0.0001 nits精度

      // MaxCLL和MaxFALL（可选）
      const maxCLL = data.length >= 22 ? view.getUint16(20) : maxLuminance;
      const maxFALL = data.length >= 24 ? view.getUint16(22) : maxLuminance;

      this.staticMetadata = {
        displayPrimaries: [
          [greenX, greenY],
          [blueX, blueY],
          [redX, redY],
        ],
        whitePoint: [whiteX, whiteY],
        maxDisplayLuminance: maxLuminance,
        minDisplayLuminance: minLuminance,
        maxContentLightLevel: maxCLL,
        maxFrameAverageLightLevel: maxFALL,
      };

      console.info(`[HDRAnalyzer] HDR10元数据: 峰值亮度=${maxLuminance}nits, ` +
        `MaxCLL=${maxCLL}nits, MaxFALL=${maxFALL}nits`);

      return this.staticMetadata;
    } catch (error) {
      console.error('[HDRAnalyzer] 元数据解析失败');
      return null;
    }
  }
}

/**
 * HDR分析结果
 */
interface HDRAnalysisResult {
  isHDR: boolean;              // 是否为HDR内容
  hdrType: string;             // HDR类型名称
  peakLuminance: number;       // 峰值亮度（nits）
  recommendedMapping: string;  // 推荐的色调映射算法
  colorSpace: string;          // 色彩空间
  bitDepth: number;            // 色深
}

/**
 * SDR兼容策略
 */
interface SDRCompatibilityStrategy {
  toneMappingAlgorithm: string;    // 色调映射算法
  colorSpaceConversion: boolean;   // 是否需要色彩空间转换
  bitDepthReduction: boolean;      // 是否需要色深降级
  saturationAdjustment: number;    // 饱和度调整系数
  brightnessCompensation: number;  // 亮度补偿值
}

四、踩坑与注意事项

4.1 HDR开发常见陷阱

4.2 性能优化建议

1. 硬件解码优先：HDR视频的10-bit解码非常耗CPU，务必使用硬件解码器
2. 色调映射GPU加速：通过Shader实现色调映射，避免CPU逐像素计算
3. 避免实时像素操作：不要在ArkTS层逐像素做色调映射，性能不可接受
4. 预计算LUT：将色调映射曲线预计算为查找表（LUT），运行时查表代替计算

4.3 色调映射算法选择指南

五、HarmonyOS 6适配

5.1 API变更

5.2 迁移指南

// HarmonyOS 6 使用内置色调映射
import { media } from '@kit.MediaKit';

async function playHDRWithBuiltinToneMapping(videoPath: string): Promise<void> {
  const avPlayer = await media.createAVPlayer();

  // HarmonyOS 6: 设置色调映射模式
  avPlayer.setToneMappingMode(media.ToneMappingMode.AUTO); // 自动选择最优算法

  // 或者手动指定
  avPlayer.setToneMappingMode(media.ToneMappingMode.BT2390);

  avPlayer.url = videoPath;
  await avPlayer.play();
}

5.3 HarmonyOS 6 HDR录制

// HarmonyOS 6: 录制HDR视频
import { media } from '@kit.MediaKit';

async function recordHDRVideo(): Promise<void> {
  const avRecorder = await media.createAVRecorder();

  const config: media.AVRecorderConfig = {
    audioSourceType: media.AudioSourceType.AUDIO_SOURCE_TYPE_MIC,
    videoSourceType: media.VideoSourceType.VIDEO_SOURCE_TYPE_SURFACE_ES,
    profile: {
      audioBitrate: 192000,
      audioChannels: 2,
      audioCodec: media.CodecMimeType.AUDIO_AAC,
      audioSampleRate: 48000,
      fileFormat: media.ContainerFormatType.CFT_MPEG_4,
      videoBitrate: 20000000,  // HDR需要更高码率
      videoCodec: media.CodecMimeType.VIDEO_HEVC,  // H.265更适合HDR
      videoFrameWidth: 1920,
      videoFrameHeight: 1080,
      videoFrameRate: 30,
      isHdr: true,  // 开启HDR录制
    },
    url: 'fd://video_output.mp4',
  };

  await avRecorder.prepare(config);
  await avRecorder.start();
}

六、总结

mindmap
  root((HDR视频))
    HDR标准
      HDR10
        静态元数据
        PQ传输函数
        开放免费
      HDR10+
        动态元数据
        逐帧优化
      HLG
        场景参考
        SDR兼容
        广播标准
      Dolby Vision
        动态RPU
        12-bit色深
        付费授权
    渲染管线
      HDR路径
        PQ/HLG传输函数
        BT.2020色彩空间
        元数据应用
      SDR路径
        色调映射
        色彩空间转换
        色深降级
    色调映射
      Reinhard
        简单高效
        实时处理
      Hable
        电影级效果
        高光保留
      ACES
        工业标准
        色彩自然
      BT.2390
        广播标准
        PQ专用
    元数据
      静态元数据
        MaxCLL/MaxFALL
        显示器参数
      动态元数据
        逐帧参数
        HDR10+/DV
    SDR兼容
      色调映射选择
      色彩空间转换
      饱和度调整
      亮度补偿
    HarmonyOS 6
      Dolby Vision支持
      内置ToneMapper
      HDR录制
      HDR截图
      色彩空间管理

关键要点回顾：

1. HDR不是一种标准，是一堆标准：HDR10最通用，HLG最兼容，Dolby Vision最强但需授权
2. 色调映射是HDR→SDR的关键：Reinhard简单、ACES自然、BT.2390标准，根据场景选择
3. 色彩空间转换不能忘：BT.2020→BT.709，不做转换颜色会偏
4. HLG是唯一SDR兼容的HDR格式：在SDR屏幕上也能正常显示，这是它的核心优势
5. HarmonyOS 6大幅增强HDR能力：内置色调映射、Dolby Vision支持、HDR录制，开发成本大幅降低

下一篇我们将深入视频安全技术，看看DRM数字版权管理、Widevine、视频加密和防录屏是如何保护视频内容的。