HarmonyOS中 ImageReceiver 支持的格式和相机输出的格式不匹配？

Question

HarmonyOS中 ImageReceiver 支持的格式和相机输出的格式不匹配？

春暖花开

18.4k28230

发布于
2024-10-11 上海

ImageReceiver 支持的格式和相机输出的格式不匹配，导致无法使用 ImageReceiver 来读取相机的预览数据。

harmonyos

阅读 713

AI BotBETA

在HarmonyOS开发中，如果遇到ImageReceiver支持的格式与相机（Camera）输出的格式不匹配的问题，这通常意味着你需要进行某种形式的格式转换或调整相机的输出设置以匹配ImageReceiver的期望。以下是一些可能的解决步骤：

1. 检查并调整相机输出格式

首先，你需要确认相机的输出格式，这通常包括图像数据的编码方式（如YUV、JPEG等）和分辨率。然后，查看ImageReceiver是否支持这些格式。如果不支持，你可能需要修改相机的输出设置，以生成ImageReceiver可以处理的格式。

在HarmonyOS的Camera API中，通常可以设置预览的格式和分辨率。例如，你可以尝试将相机的输出设置为YUV_420_888等常用格式，这是许多图像处理组件和库都能支持的格式。

2. 使用转换工具或库

如果调整相机输出格式不可行或不受支持，你可能需要使用图像转换工具或库来将相机输出的格式转换为ImageReceiver可以接受的格式。例如，如果相机输出JPEG格式而ImageReceiver需要YUV格式，你可以使用图像处理库（如OpenCV）来解码JPEG图像并转换为YUV格式。

3. 自定义处理

如果上述方法都不可行，你可能需要编写自定义的代码来处理相机输出数据，并在传递给ImageReceiver之前进行必要的转换。这可能涉及到对图像数据的直接操作，如像素数据的复制和转换。

4. 查阅文档和社区资源

HarmonyOS的官方文档和社区论坛是获取帮助的好地方。查看相关文档以了解ImageReceiver的具体要求和限制，以及相机API的使用说明。此外，社区论坛中可能有其他开发者遇到并解决了类似的问题，他们的经验可能会对你有所帮助。

示例代码（假设性）

由于具体的实现细节会依赖于你的项目设置和使用的库，这里只能提供一个非常简化的示例框架：

// 假设你已经有了一个Camera实例和ImageReceiver实例
Camera camera = ...;
ImageReceiver imageReceiver = ...;

// 设置相机输出格式（示例，具体API可能不同）
camera.setOutputFormat(Camera.OutputFormat.YUV_420_888);

// 相机回调中处理预览数据
camera.setPreviewCallback(new Camera.PreviewCallback() {
    @Override
    public void onPreviewFrame(byte[] data, Camera camera) {
        // 在这里，data是相机输出的原始数据
        // 你可能需要将数据转换为ImageReceiver可以接受的格式
        // ...（转换逻辑）

        // 将转换后的数据传递给ImageReceiver
        // imageReceiver.setImageData(...); // 假设有这样的API
    }
});

请注意，上述代码是假设性的，并不直接适用于HarmonyOS的Camera API，因为实际的API和类名可能会有所不同。你需要根据自己的项目设置和HarmonyOS的文档来调整代码。

1 个回答

得票最新

三掌柜

37.2k431302

发布于
2024-10-11 上海

✓ 已被采纳

ImageReceiver 支持的格式和相机输出的格式不匹配并不影响预览功能的正常使用，底层对于image.ComponentType.JPEG的类型并没有处理，不影响正常的预览功能，这边编写了一个demo，ArrayBuffer可以获取到NV21帧数据：

import camera from '@ohos.multimedia.camera'; 
import image from '@ohos.multimedia.image'; 
import abilityAccessCtrl from '@ohos.abilityAccessCtrl'; 
import common from '@ohos.app.ability.common'; 
import fs from '@ohos.file.fs'; 
import { BusinessError } from '@kit.BasicServicesKit'; 
import PhotoAccessHelper from '@ohos.file.photoAccessHelper'; 
import { ifaa } from '@kit.OnlineAuthenticationKit'; 
@Entry 
@Component 
struct Page1 { 
  @State message: string = 'Hello World' 
  private mXComponentController: XComponentController = new XComponentController; 
  private surfaceId: string = '-1'; 
  @State imgUrl: PixelMap | undefined = undefined; 
  private context: ESObject = undefined 
  private previewProfilesObj2: camera.Profile | undefined = undefined; 
  private receiver: image.ImageReceiver | undefined = undefined; 
  @State pixma: PixelMap | undefined = undefined 
  @State photoOutput: camera.PhotoOutput | undefined = undefined; 
  aboutToAppear() { 
    //申请权限 
    let context = getContext() as common.UIAbilityContext; 
    abilityAccessCtrl.createAtManager().requestPermissionsFromUser(context, ['ohos.permission.CAMERA']).then(() => { 
      this.createDualChannelPreview(this.surfaceId); 
    }); 
  } 
  onPageShow(): void { 
    this.createDualChannelPreview(this.surfaceId); 
  } 
  async createDualChannelPreview(XComponentSurfaceId: string): Promise<void> { 
    let cameraManager = await camera.getCameraManager(getContext() as ESObject); 
    let camerasDevices: Array<camera.CameraDevice> = cameraManager.getSupportedCameras(); // 获取支持的相机设备对象 
    // 获取profile对象 
    let profiles: camera.CameraOutputCapability = cameraManager.getSupportedOutputCapability(camerasDevices[0]); // 获取对应相机设备profiles 
    let previewProfiles: Array<camera.Profile> = profiles.previewProfiles; 
    // 预览流2 
    this.previewProfilesObj2 = previewProfiles[0]; 
    this.receiver = image.createImageReceiver(this.previewProfilesObj2.size.width, this.previewProfilesObj2.size.height, 2000, 8); 
    // 创建 预览流2 输出对象 
    let imageReceiverSurfaceId: string = await this.receiver.getReceivingSurfaceId(); 
    let previewOutput2: camera.PreviewOutput = cameraManager.createPreviewOutput(this.previewProfilesObj2, imageReceiverSurfaceId); 
    // 创建拍照输出流 
    let photoProfilesArray: Array<camera.Profile> = profiles.photoProfiles; 
    try { 
      this.photoOutput = cameraManager.createPhotoOutput(photoProfilesArray[0]); 
    } catch (error) { 
      let err = error as BusinessError; 
      console.error('Failed to createPhotoOutput errorCode = ' + err.code); 
    } 
    if (this.photoOutput === undefined) { 
      return; 
    } 
    // 创建cameraInput对象 
    let cameraInput: camera.CameraInput = cameraManager.createCameraInput(camerasDevices[0]); 
    // 打开相机 
    await cameraInput.open(); 
    // 会话流程 
    let captureSession: camera.CaptureSession = cameraManager.createCaptureSession(); 
    // 开始配置会话 
    captureSession.beginConfig(); 
    // 把CameraInput加入到会话 
    captureSession.addInput(cameraInput); 
    // 把 预览流2 加入到会话 
    captureSession.addOutput(previewOutput2); 
    try { 
      captureSession.addOutput(this.photoOutput); 
    } catch (error) { 
      let err = error as BusinessError; 
      console.error('Failed to addOutput(photoOutput). errorCode = ' + err.code); 
    } 
    // 提交配置信息 
    await captureSession.commitConfig(); 
    // 会话开始 
    await captureSession.start(); 
    this.onImageArrival(this.receiver); 
    this.setPhotoOutputCb(this.photoOutput) 
 
  } 
  async savePicture(buffer: ArrayBuffer, img: image.Image) { 
    const context = getContext(this); 
    let photoAccessHelper: PhotoAccessHelper.PhotoAccessHelper = PhotoAccessHelper.getPhotoAccessHelper(context); 
    let options: PhotoAccessHelper.CreateOptions = { 
      title: Date.now().toString() 
    }; 
    let photoUri: string = await photoAccessHelper.createAsset(PhotoAccessHelper.PhotoType.IMAGE, 'jpg', options); 
    //createAsset的调用需要ohos.permission.READ_IMAGEVIDEO和ohos.permission.WRITE_IMAGEVIDEO的权限 
    let file: fs.File = fs.openSync(photoUri, fs.OpenMode.READ_WRITE | fs.OpenMode.CREATE); 
    await fs.write(file.fd, buffer); 
    fs.closeSync(file); 
    img.release(); 
  } 
  setPhotoOutputCb(photoOutput: camera.PhotoOutput) { 
    //设置回调之后，调用photoOutput的capture方法，就会将拍照的buffer回传到回调中 
    photoOutput.on('photoAvailable', (errCode: BusinessError, photo: camera.Photo): void => { 
      console.info('getPhoto start'); 
      console.info(`err: ${JSON.stringify(errCode)}`); 
      if (errCode || photo === undefined) { 
        console.error('getPhoto failed'); 
        return; 
      } 
      let imageObj = photo.main; 
      imageObj.getComponent(image.ComponentType.JPEG, (errCode: BusinessError, component: image.Component): void => { 
        console.info('getComponent start'); 
        if (errCode || component === undefined) { 
          console.error('getComponent failed'); 
          return; 
        } 
        let buffer: ArrayBuffer; 
        if (component.byteBuffer) { 
          buffer = component.byteBuffer; 
          if (component.byteBuffer as ArrayBuffer) { 
            let sourceOptions: image.SourceOptions = { 
              sourceDensity: 120, 
              // sourcePixelFormat: 3, // NV21 
              sourceSize: { 
                height: 240, 
                width: 320 
              }, 
            } 
            try { 
              let imageResource = image.createImageSource(component.byteBuffer); 
              imageResource.createPixelMap({}).then((res)=>{ 
                this.pixma = res; 
              }); 
            }catch (error) { 
              let err = error as BusinessError; 
              console.error('Failed to addOutput(photoOutput). errorCode = ' + err.code); 
            } 
          } else { 
            return; 
          } 
        } else { 
          console.error('byteBuffer is null'); 
          return; 
        } 
        this.savePicture(buffer, imageObj); 
      }); 
    }); 
  } 
  async onImageArrival(receiver: image.ImageReceiver): Promise<void> { 
    receiver.on('imageArrival', () => { 
      console.error("imageArrival callback"); 
      receiver.readLatestImage((err, nextImage: image.Image) => { 
        if (err || nextImage === undefined) { 
          return; 
        } 
        nextImage.getComponent(image.ComponentType.JPEG, async (err, imgComponent: image.Component) => { 
          if (err || imgComponent === undefined) { 
            return; 
          } 
          this.saveImageToFile(imgComponent.byteBuffer); 
          if (imgComponent.byteBuffer as ArrayBuffer) { 
            let sourceOptions: image.SourceOptions = { 
              sourceDensity: 120, 
              sourcePixelFormat: 8, // NV21 
              sourceSize: { 
                height: this.previewProfilesObj2!.size.height, 
                width: this.previewProfilesObj2!.size.width 
              }, 
            } 
            let imageResource = image.createImageSource(imgComponent.byteBuffer, sourceOptions); 
            let decodingOptions : image.DecodingOptions = { 
              editable: true, 
              desiredPixelFormat: 3, 
            } 
            imageResource.createPixelMap(decodingOptions).then((res)=>{ 
              this.imgUrl = res; 
            }); 
          } else { 
            return; 
          } 
          nextImage.release(); 
        }) 
      }) 
    }) 
  } 
  saveImageToFile(data: ArrayBuffer) { 
    const context = getContext(this); 
    let filePath = context.tempDir + "/test.jpg"; 
    console.info("path is " + filePath); 
    let file = fs.openSync(filePath, fs.OpenMode.READ_WRITE | fs.OpenMode.CREATE); 
    fs.write(file.fd, data, (err, writeLen) => { 
      if (err) { 
        console.info("write failed with error message: " + err.message + ", error code: " + err.code); 
      } else { 
        console.info("write data to file succeed and size is:" + writeLen); 
        fs.closeSync(file); 
      } 
    }); 
    this.saveImageToFile(imgComponent.byteBuffer); 
    if (imgComponent.byteBuffer as ArrayBuffer) { 
      let sourceOptions: image.SourceOptions = { 
        sourceDensity: 120, 
        sourcePixelFormat: 8, // NV21 
        sourceSize: { 
          height: this.previewProfilesObj2!.size.height, 
          width: this.previewProfilesObj2!.size.width 
        }, 
      } 
      let imageResource = image.createImageSource(imgComponent.byteBuffer, sourceOptions); 
      let decodingOptions : image.DecodingOptions = { 
        editable: true, 
        desiredPixelFormat: 3, 
      } 
      imageResource.createPixelMap(decodingOptions).then((res)=>{ 
        this.imgUrl = res; 
      }); 
    } else { 
      return; 
    } 
    nextImage.release(); 
  }) 
}) 
}) 
} 
saveImageToFile(data: ArrayBuffer) { 
  const context = getContext(this); 
  let filePath = context.tempDir + "/test.jpg"; 
  console.info("path is " + filePath); 
  let file = fs.openSync(filePath, fs.OpenMode.READ_WRITE | fs.OpenMode.CREATE); 
  fs.write(file.fd, data, (err, writeLen) => { 
    if (err) { 
      console.info("write failed with error message: " + err.message + ", error code: " + err.code); 
    } else { 
      console.info("write data to file succeed and size is:" + writeLen); 
      fs.closeSync(file); 
    } 
  }); 
  // context.tempDir + "/test.jpg" 对应绝对路径 /data/app/el2/100/base/com.example.image_example/haps/Packer/temp/test.jpg （也可通过hdc shell 查询对应目录） 
  // hdc file recv /data/app/el2/100/base/com.example.image_example/haps/Packer/temp/test.jpg D:\ （获取文件到本地，查看保存结果） 
} 
build() { 
  Column() { 
    Row() { 
      // 将编辑好的pixelMap传递给状态变量imagePixelMap后，通过Image组件进行渲染 
      Image(this.imgUrl).objectFit(ImageFit.None) 
    }.width('100%').height('50%').backgroundColor('#F0F0F0') 
    Row() { 
      Button() { 
        Text("拍照") 
          .fontColor(Color.Black) 
          .alignSelf(ItemAlign.Center) 
          .onClick(() => { 
            let settings: camera.PhotoCaptureSetting = { 
              quality: camera.QualityLevel.QUALITY_LEVEL_HIGH, // 设置图片质量高 
              rotation: camera.ImageRotation.ROTATION_0, // 设置图片旋转角度0 
              mirror: false // 设置镜像使能开关(默认关) 
            }; 
            if (this.photoOutput){ 
              this.photoOutput.capture(settings, (err: BusinessError) => { 
                if (err) { 
                  console.error(`Failed to capture the photo. error: ${JSON.stringify(err)}`); 
                  return; 
                } 
                console.info('Callback invoked to indicate the photo capture request success.'); 
              }); 
            } 
          }) 
      } 
      .width(100) 
      .height(100) 
      Image(this.pixma) 
        .width(200) 
        .height(200) 
    } 
  } 
} 
}

撰写回答

你尚未登录，登录后可以

和开发者交流问题的细节
关注并接收问题和回答的更新提醒
参与内容的编辑和改进，让解决方法与时俱进

推荐问题

HarmonyOS

子站问答

访问

相似问题

找不到问题？创建新问题

HarmonyOS中 ImageReceiver 支持的格式和相机输出的格式不匹配？

1. 检查并调整相机输出格式

2. 使用转换工具或库

3. 自定义处理

4. 查阅文档和社区资源

示例代码（假设性）

你尚未登录，登录后可以

如何在WebMessagePort中发送复杂对象？

复杂动画出现帧率抖动是什么原因?

如何解决新API在旧版本系统中导致的崩溃问题？

鸿蒙系统启动内存测试方法有哪些？

如何解决组件样式不生效的问题？

在开发基于鸿蒙原子化服务的过程中，如何实现服务的快速加载，提升用户使用体验？

如何在父组件中高效管理多个依赖状态的子组件？

HarmonyOS