VENC视频编码

VENC（Video Encoder）将YUV420SP格式的图片编码成H264/H265格式的视频码流。关于VENC功能的详细介绍及约束请参见功能及约束说明。

本节介绍VENC视频编码的接口调用流程，同时配合示例代码辅助理解该接口调用流程。

接口调用流程

开发应用时，如果涉及视频编码，则应用程序中必须包含视频编码的代码逻辑，关于视频编码的接口调用流程，请先参见pyACL接口调用流程了解整体流程，再查看本节中的流程说明。

图1 视频编码流程

实现视频的编码，关键接口的说明如下：

调用acl.media.venc_create_channel接口创建视频编码处理的通道。
- 创建视频编码处理通道前，需先执行以下操作：
  1. 调用acl.media.venc_create_channel_desc接口创建通道描述信息。
  2. 调用acl.media.venc_set_channel_desc_param接口设置通道描述信息的属性，包括线程、回调函数、视频编码协议、输入图片格式等，其中：
    1. 回调函数需由用户提前创建，用于在视频编码后，获取编码数据，并及时释放相关资源，回调函数的原型前参见函数：venc_set_channel_desc_callback。
      
      视频编码结束后，建议用户在回调函数内及时释放输入图片内存、以及相应的图片描述信息。视频编码的输出内存由系统管理，不由用户管理，因此无需用户释放。
    2. 线程需由用户提前创建，并自定义线程函数，在线程函数内调用acl.rt.process_report接口，等待指定时间后，触发1.b.i中的回调函数。
    :::note 说明推荐使用acl.media.venc_set_channel_desc_param接口设置通道描述信息的属性，通过枚举值来选择通过该接口设置某一个属性的值。
    
    但为兼容旧版本，也可以调用acl.media.venc.set_channel_desc系列接口设置通道描述信息的属性，每个属性的设置对应一个set接口。 :::
- acl.media.venc_create_channel接口内部封装了如下接口，无需用户单独调用：
  1. acl.rt.create_stream接口：显式创建Stream，VENC内部使用。
  2. acl.rt.subscribe_report接口：指定处理Stream上回调函数的线程，回调函数和线程是由用户调用acl.media.venc_set_channel_desc_param接口时指定的。
调用acl.media.venc_send_frame接口将YUV420SP格式的图片编码成H264/H265格式的视频码流。
- 视频编码前，需先执行以下操作：
  - 调用acl.media.dvpp_create_pic_desc接口创建输入图片描述信息，并调用acl.media.dvpp_set_pic_desc系列接口设置输入图片的内存地址、内存大小、图片格式等属性。
  - 调用acl.media.venc_create_frame_config接口创建单帧编码配置数据，并调用acl.media.venc_set_frame_config系列接口设置是否强制重新开始I帧间隔、是否结束帧。
- 视频编码时，acl.media.venc_send_frame接口内部封装了acl.rt.launch_callback接口，用于在Stream的任务队列中增加一个需要执行的回调函数。用户无需单独调用acl.rt.launch_callback接口。
- 视频编码后，视频编码的结果数据通过回调函数获取。
调用acl.media.venc_destroy_channel接口销毁视频处理的通道。
- 系统会等待已发送帧编码完成且用户的回调函数处理完成后再销毁通道。
- acl.media.venc_destroy_channel接口内部封装了如下接口，无需用户单独调用。
  - acl.rt.unsubscribe_report接口：取消线程注册（Stream上的回调函数不再由指定线程处理）。
  - acl.rt.destroy_stream接口：销毁Stream。
- 销毁通道后，需调用acl.media.venc_destroy_channel_desc接口销毁通道描述信息。
- 销毁通道描述信息后，用户才可以销毁1.b.ii中创建的线程。

示例代码

调用接口后，需增加异常处理的分支，并记录报错日志、提示日志，此处不一一列举。以下是关键步骤的代码示例，不可以直接拷贝运行，仅供参考。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 python import acl # ...... # 1.资源初始化: 创建 AclVenc 对象进行初始化。 # 1.1 pyACL初始化。 ret = acl.init() # 1.2 运行管理资源申请,包括Device、Context。 device_id = 0 ret = acl.rt.set_device(device_id) self.context, ret = acl.rt.create_context(device_id) # 调用acl.rt.get_run_mode接口获取软件栈的运行模式，根据运行模式来判断后续的内存申请接口调用逻辑。 runMode, ret = acl.rt.get_run_mode() # 2.创建执行回调函数的线程及线程函数。 def cb_thread_func(self, args_list): ctx = args_list[0] timeout = args_list[1] print("[info] thread args_list = ", self.ctx, timeout, self.g_callbackRunFlag, "\n") ret = acl.rt.set_context(ctx) assert ret == 0 while self.g_callbackRunFlag is True: print("[info] thread g_callbackRunFlag = ", self.g_callbackRunFlag, "\n") ret = acl.rt.process_report(timeout) print("[info] acl.rt.process_report =", ret) timeout = 1000 g_callbackRunFlag = True self.cb_thread_id, ret = acl.util.start_thread(self.cb_thread_func, [self.ctx, timeout]) # 3.创建回调函数。 # 3.1 获取流数据输出。 def get_stream_data(self, stream_desc): stream_data = acl.media.dvpp_get_stream_desc_data(stream_desc) assert stream_data is not None stream_data_size = acl.media.dvpp_get_stream_desc_size(stream_desc) print("[info] stream_data size", stream_data_size) # stream memcpy d2h np_data = np.zeros(stream_data_size, dtype=np.byte) bytes_data = np_data.tobytes() np_data_ptr = acl.util.bytes_to_ptr(bytes_data) ret = acl.rt.memcpy(np_data_ptr, stream_data_size, stream_data, stream_data_size, memcpy_kind.get("ACL_MEMCPY_DEVICE_TO_HOST")) assert ret == 0 return np_data # 3.2 回调函数将视频流保存文件。 def callback_func(self, input_pic_desc, output_stream_desc, user_data): # 获取视频编码结果数据, 转换成numpy对象。 output_numpy = self.get_stream_data(output_stream_desc) with open('./data/output.h265', 'ab') as f: f.write(output_numpy) print("[INFO] [callback_func] stream size =", acl.media.dvpp_get_stream_desc_size(output_stream_desc)) # 4.创建视频编码处理通道时的通道描述信息。 self.venc_channel_desc = acl.media.venc_create_channel_desc() # 5.设置通道描述信息的属性，其中线程、callback回调函数需要用户提前创建。 # vencChannelDesc_是aclvdecChannelDesc类型。 venc_format = 1 venc_entype = 0 input_width = 1280 input_height = 720 ret = acl.media.venc_set_channel_desc_thread_id(self.venc_channel_desc, self.cb_thread_id) ret = acl.media.venc_set_channel_desc_callback(self.venc_channel_desc, self.callback_func) ret = acl.media.venc_set_channel_desc_entype(self.venc_channel_desc, venc_entype) ret = acl.media.venc_set_channel_desc_pic_format(self.venc_channel_desc, venc_format) ret = acl.media.venc_set_channel_desc_key_frame_interval(self.venc_channel_desc, 16) ret = acl.media.venc_set_channel_desc_pic_height(self.venc_channel_desc, input_height) ret = acl.media.venc_set_channel_desc_pic_width(self.venc_channel_desc, input_width ) # 6.创建视频码流处理的通道、单帧编码配置数据。 ret = acl.media.venc_create_channel(self.venc_channel_desc) # vencFrameConfig_是aclvencFrameConfig类型。 frame_config = acl.media.venc_create_frame_config() # 7.申请Device内存dataDev，存放视频编码的输入数据。 # 7.1 读入图片数据。 output_pic_size = (input_width * input_height * 3) // 2 print("[INFO] output_pic_size:", output_pic_size, " load vdec file:", venc_file_path) file_context = np.fromfile(venc_file_path, dtype=np.byte) file_size = file_context.size bytes_data = file_context.tobytes() file_mem = acl.util.bytes_to_ptr(bytes_data) input_size = file_size # 如果调用acl.rt.get_run_mode接口获取软件栈的运行模式为ACL_HOST，则需要通过acl.rt.memcpy接口将Host的图片数据传输到Device，数据传输完成后，需及时调用acl.rt.free_host接口释放Host内存。 # 如果调用acl.rt.get_run_mode接口获取软件栈的运行模式为ACL_DEVICE，则直接申请Device内存，存放输入图片数据。 # 此处是运行模式为 ACL_HOST。 input_mem, ret = acl.media.dvpp_malloc(input_size) assert ret == 0 ret = acl.rt.memcpy(input_mem, input_size, file_mem, file_size, memcpy_kind.get("ACL_MEMCPY_HOST_TO_DEVICE")) assert ret == 0 # 8.执行视频编码。 def venc_set_frame_config(self, frame_confg, eos, iframe): ret = acl.media.venc_set_frame_config_eos(frame_confg, eos) assert ret == 0 ret = acl.media.venc_set_frame_config_force_i_frame(frame_confg, iframe) assert ret == 0 def venc_process(self, venc_channel_desc, input_mem, input_size, frame_config): # 设置为非结束帧。 self.venc_set_frame_config(frame_config, 0, 0) print("[INFO] set frame config") self.test_get_frame_config(frame_config) # set picture description dvpp_pic_desc = acl.media.dvpp_create_pic_desc() assert dvpp_pic_desc is not None ret = acl.media.dvpp_set_pic_desc_data(dvpp_pic_desc, input_mem) assert ret == 0 ret = acl.media.dvpp_set_pic_desc_size(dvpp_pic_desc, input_size) assert ret == 0 print("[INFO] set pic desc") # 发送1张图片到编码器进行编码。 venc_cnt = 16 while venc_cnt: ret = acl.media.venc_send_frame(venc_channel_desc, dvpp_pic_desc, 0, frame_config, 0) assert ret == 0 print("[INFO] venc send frame") venc_cnt -= 1 # 结束视频编码时可以发送eos为1的空图片，表示当前编码结束。 self.venc_set_frame_config(frame_config, 1, 0) ret = acl.media.venc_send_frame(venc_channel_desc, 0, 0, frame_config, 0) assert ret == 0 # 9.释放资源。 ret = acl.media.dvpp_free(input_mem) ret = acl.media.venc_destroy_frame_config(frame_config) assert ret == 0 print("[INFO] free resources") g_callbackRunFlag = False ret = acl.util.stop_thread(self.cb_thread_id) print("[INFO] thread join") # 10. 释放运行管理资源。 ret = acl.rt.destroy_stream(self.stream) ret = acl.rt.destroy_context(self.context) ret = acl.rt.reset_device(self.device_id); ret = acl.finalize() # 11.pyACL去初始化。 # ....

如果调用acl.media.venc_set_channel_desc_param接口设置通道描述信息的属性，调用acl.media.venc_get_channel_desc_param接口获取通道描述信息中的属性值，示例代码如下：

 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36  ACL_VENC_THREAD_ID_UINT64 = 0 #回调线程ID。 ACL_VENC_CALLBACK_PTR = 1 #回调函数。 ACL_VENC_PIXEL_FORMAT_UINT32 = 2 #输入图像格式。 ACL_VENC_ENCODE_TYPE_UINT32 = 3 #视频编码协议。 ACL_VENC_PIC_WIDTH_UINT32 = 4 #输入图片宽度。 ACL_VENC_PIC_HEIGHT_UINT32 = 5 #输入图片高度。 ACL_VENC_KEY_FRAME_INTERVAL_UINT32 = 6 #关键帧间隔。 ACL_VENC_BUF_ADDR_PTR = 7 #编码输出缓存地址。 ACL_VENC_BUF_SIZE_UINT32 = 8 #编码输出缓存大小。 ACL_VENC_RC_MODE_UINT32 = 9 #码率控制模式。 ACL_VENC_SRC_RATE_UINT32 = 10 #输入码流帧率。 ACL_VENC_MAX_BITRATE_UINT32 = 11 #输出码率。 ACL_VENC_MAX_IP_PROP_UINT32 = 12 #一个GOP内单个I帧bit数和单个P帧bit数的比例。 # 设置回调函数。 ret = acl.media.venc_set_channel_desc_param(self.venc_channel_desc, ACL_VENC_CALLBACK_PTR, self.callback_func) # 获取回调函数。 get_cb_func, ret = acl.media.venc_get_channel_desc_param(self.venc_channel_desc, ACL_VENC_CALLBACK_PTR) PIXEL_FORMAT_YUV_SEMIPLANAR_420 = 1 # 设置输入图片格式。 ret = acl.media.venc_set_channel_desc_param(self.venc_channel_desc, ACL_VENC_PIXEL_FORMAT_UINT32, PIXEL_FORMAT_YUV_SEMIPLANAR_420) # 获取输入图片格式。 get_pic_format, ret = acl.media.venc_get_channel_desc_param(self.venc_channel_desc, ACL_VENC_PIXEL_FORMAT_UINT32) width = 128 # 设置图片宽度。 ret = acl.media.venc_set_channel_desc_param(self.venc_channel_desc, ACL_VENC_PIC_WIDTH_UINT32, width) # 获取图片宽度。 get_width, ret = acl.media.venc_get_channel_desc_param(self.venc_channel_desc, ACL_VENC_PIC_WIDTH_UINT32) height = 128 # 设置图片高度。 ret = acl.media.venc_set_channel_desc_param(self.venc_channel_desc, ACL_VENC_PIC_HEIGHT_UINT32, height) # 获取图片高度。 get_height, ret = acl.media.venc_get_channel_desc_param(self.venc_channel_desc, ACL_VENC_PIC_HEIGHT_UINT32)

父主题： 媒体数据处理V1

功能支持度说明

昇腾AI处理器对媒体数据处理V2版本各功能的支持度如下表所示。

昇腾AI处理器	VPC	JPEGD	JPEGE	PNGD	VDEC	VENC
Atlas 200/500 A2推理产品	√	√	√	√	√	√

父主题： 媒体数据处理V2

VPC图片处理典型功能

VPC（Vision Preprocessing Core）负责图像处理功能，支持对图片做抠图、缩放、格式转换等操作。关于VPC功能的详细介绍请参见VPC功能，关于VPC功能对输入、输出的约束要求，请参见约束说明。

本节以抠图、缩放为例说明VPC图像处理时的接口调用流程，同时配合以下典型功能的示例代码辅助理解该接口调用流程：

图片缩放示例代码
抠图示例代码

典型功能接口调用流程（以缩放为例）

开发应用时，如果涉及抠图、缩放等图片处理，则应用程序中必须包含图片处理的代码逻辑，关于图片处理的接口调用流程，请先参见pyACL接口调用流程了解整体流程，再查看本节中的流程说明。

图1 接口调用流程（以缩放为例）

当前系统支持对输入图片做抠图、缩放等处理，关键接口的说明如下：

调用acl.himpi.sys_init接口进行媒体数据处理系统初始化。
调用acl.himpi.vpc_create_chn接口创建通道。
调用acl.himpi.dvpp_malloc接口申请Device上的内存，存放输入或输出数据。
执行抠图、缩放等，此步骤以缩放为例说明，其它功能（例如格式转换、金字塔等）请参见VPC功能下的接口说明。

调用acl.himpi.vpc_resize接口，按指定区域从输入图片中抠图，抠出的图作为输出图片。acl.himpi.vpc_resize接口是异步接口，调用该接口成功仅表示任务下发成功，还需要调用acl.himpi.vpc_get_process_result接口等待任务完成。
- 可以跟acl.himpi.vpc_resize接口在同一个线程中调用acl.himpi.vpc_get_process_result接口，也可以新起一个线程调用acl.himpi.vpc_get_process_result接口，后者多线程并行，提高效率，但用户需自行实现线程间同步。
- 在实现抠图、缩放等功能时，通过将输入图片和输出图片的格式设置成不同的，达到转换图片格式的目的。
调用acl.himpi.dvpp_free接口释放输入、输出内存。
调用acl.himpi.vpc_destroy_chn接口销毁通道。
调用acl.himpi.sys_exit接口进行媒体数据处理系统去初始化。

图片缩放示例代码

调用接口后，需增加异常处理的分支，并记录报错日志、提示日志，此处不一一列举。以下是关键步骤的代码示例，不可以直接拷贝运行，仅供参考。

## 1.获取软件栈的运行模式，不同运行模式影响后续的接口调用流程（例如是否进行数据传输等）。
run_mode, ret = acl.rt.get_run_mode()

## 2.pyACL 初始化。
ret = acl.init()

## 3.运行管理资源申请(依次申请Device、Context)。
ret = acl.rt.set_device(0)
context, ret = acl.rt.create_context(0)

## 4.初始化媒体数据处理系统。
ret = acl.himpi.sys_init()

## 5.创建通道。
channel_id = 0
chn_attr = &#123;'attr': 0, 'pic_width': 0, 'pic_height': 0&#125;
ret = acl.himpi.vpc_create_chn(channel_id, chn_attr)

## 6.执行缩放。
## 6.1 构造存放输入图片信息的字典。
input_pic = &#123;'picture_width': 1920,
             'picture_height': 1080,
             'picture_width_stride': 1920,
             'picture_height_stride': 1080,
             'picture_format': HI_PIXEL_FORMAT_YUV_SEMIPLANAR_420&#125;
input_pic["picture_buffer_size"] = input_pic["picture_width_stride"] * input_pic["picture_height_stride"] * 3 // 2
picture_address, ret = acl.himpi.dvpp_malloc(0, input_pic["picture_buffer_size"])
input_pic["picture_address"] = picture_address

## 如果运行模式为ACL_HOST，则需要申请Host内存，将输入图片数据读入Host内存，再通过acl.rt.memcpy接口将Host的图片数据传输到Device，数据传输完成后，需及时释放Host内存；否则直接将输入图片数据读入Device内存。
## 直接将输入图片数据读入Device内存。
if run_mode == ACL_HOST:
    # 将输入图片读入内存中。
    vpc_file = np.fromfile(vpc_file_path, dtype=np.byte)
    vpc_file_size = vpc_file.itemsize * vpc_file.size
    
    bytes_data = vpc_file.tobytes()
    vpc_file_ptr = acl.util.bytes_to_ptr(bytes_data)
    # 数据传输。
    ret = acl.rt.memcpy(input_pic["picture_address"], input_pic["picture_buffer_size"],
                        vpc_file_ptr, vpc_file_size, ACL_MEMCPY_HOST_TO_DEVICE)
else:
    # 将输入图片读入内存中。
    vpc_file = np.fromfile(vpc_file_path, dtype=np.byte)
    vpc_file_size = vpc_file.itemsize * vpc_file.size
    
    bytes_data = vpc_file.tobytes()
    vpc_file_ptr = acl.util.bytes_to_ptr(bytes_data)
    # 数据传输。
    ret = acl.rt.memcpy(input_pic["picture_address"], input_pic["picture_buffer_size"],
                        vpc_file_ptr, vpc_file_size, ACL_MEMCPY_DEVICE_TO_DEVICE)

## 6.3 构造存放输出图片信息的字典。
output_pic = &#123;'picture_width': 960,
                'picture_height': 540,
                'picture_width_stride': 960,
                'picture_height_stride': 540,
                'picture_format': HI_PIXEL_FORMAT_YUV_SEMIPLANAR_420&#125;
output_pic["picture_buffer_size"] = output_pic["picture_width_stride"] * output_pic["picture_height_stride"] * 3 // 2
picture_address, ret = acl.himpi.dvpp_malloc(0, output_pic["picture_buffer_size"])
output_pic["picture_address"] = picture_address
## 初始化内存。
ret = acl.rt.memset(output_pic["picture_address"], output_pic["picture_buffer_size"], 0, output_pic["picture_buffer_size"])

## 6.4 调用缩放接口。
testid, ret = acl.himpi.vpc_resize(channel_id, input_pic, output_pic, 0, 0, 0, -1)

## 6.5 等待任务处理结束，任务处理结束后，输出图片数据在outputPic.picture_address指向的内存中。
ret = acl.himpi.vpc_get_process_result(channel_id, task_id, -1)

## 6.6 如果运行模式为ACL_HOST，且Host上需要展示VPC输出的图片数据，则需要申请Host内存，通过acl.rt.memcpy接口将Device的输出图片数据传输到Host；如果Host上不需要展示VPC输出的图片数据，则VPC的输出图片数据可以直接作为模型推理的输入。
## 6.6 VPC的输出图片数据可以直接作为模型推理的输入。
if run_mode == ACL_HOST:
        np_output = np.zeros(output_pic.get('picture_buffer_size'), dtype=np.byte)
        
        bytes_data = np_output.tobytes()
        np_output_ptr = acl.util.bytes_to_ptr(bytes_data)
        ret = acl.rt.memcpy(np_output_ptr, output_pic.get('picture_buffer_size'), output_pic.get("picture_address"),
                            output_pic.get('picture_buffer_size'), ACL_MEMCPY_DEVICE_TO_HOST)
        # ......
else
    # 可以直接使用VPC的输出图片数据，在outputPic.picture_address指向的内存中。
    # ......
&#125;

## 6.7 释放输入、输出内存。
ret = acl.himpi.dvpp_free(input_pic['picture_address'])
ret = acl.himpi.dvpp_free(output_pic['picture_address'])

## 7.销毁通道。
ret = acl.himpi.vpc_destroy_chn(channel_id)

## 8. 媒体数据处理系统去初始化。
ret = acl.himpi.sys_exit()

## 9. 释放运行管理资源(依次释放Context、Device)。
ret = acl.rt.destroy_context(context)
ret = acl.rt.reset_device(0)

## 10.pyACL去初始化。
ret = acl.finalize()

抠图示例代码

调用接口后，需增加异常处理的分支，并记录报错日志、提示日志，此处不一一列举。以下是关键步骤的代码示例，不可以直接拷贝运行，仅供参考。

## 1.获取软件栈的运行模式，不同运行模式影响后续的接口调用流程（例如是否进行数据传输等）。
run_mode, ret = acl.rt.get_run_mode()

## 2.pyACL 初始化。
ret = acl.init()

## 3.运行管理资源申请(依次申请Device、Context)。
ret = acl.rt.set_device(0)
context, ret = acl.rt.create_context(0)

## 4.初始化媒体数据处理系统。
ret = acl.himpi.sys_init()

## 5.创建通道。
channel_id = 0
chn_attr = &#123;'attr': 0, 'pic_width': 0, 'pic_height': 0&#125;
ret = acl.himpi.vpc_create_chn(channel_id, chn_attr)

## 6.执行抠图。
## 6.1 构造存放输入图片信息的字典。
input_pic = &#123;'picture_width': 1920,
             'picture_height': 1080,
             'picture_width_stride': 1920,
             'picture_height_stride': 1080,
             'picture_format': HI_PIXEL_FORMAT_YUV_SEMIPLANAR_420&#125;
input_pic["picture_buffer_size"] = input_pic["picture_width_stride"] * input_pic["picture_height_stride"] * 3 // 2
picture_address, ret = acl.himpi.dvpp_malloc(0, input_pic["picture_buffer_size"])
input_pic["picture_address"] = picture_address

## 如果运行模式为ACL_HOST，则需要申请Host内存，将输入图片数据读入Host内存，再通过acl.rt.memcpy接口将Host的图片数据传输到Device，数据传输完成后，需及时释放Host内存；否则直接将输入图片数据读入Device内存。
## 直接将输入图片数据读入Device内存。
if run_mode == ACL_HOST:
    # 将输入图片读入内存中。
    vpc_file = np.fromfile(vpc_file_path, dtype=np.byte)
    vpc_file_size = vpc_file.itemsize * vpc_file.size
    
    bytes_data = vpc_file.tobytes()
    vpc_file_ptr = acl.util.bytes_to_ptr(bytes_data)
    # 数据传输。
    ret = acl.rt.memcpy(input_pic["picture_address"], input_pic["picture_buffer_size"],
                        vpc_file_ptr, vpc_file_size, ACL_MEMCPY_HOST_TO_DEVICE)
else:
    # 将输入图片读入内存中。
    vpc_file = np.fromfile(vpc_file_path, dtype=np.byte)
    vpc_file_size = vpc_file.itemsize * vpc_file.size
    
    bytes_data = vpc_file.tobytes()
    vpc_file_ptr = acl.util.bytes_to_ptr(bytes_data)
    # 数据传输。
    ret = acl.rt.memcpy(input_addr, input_size, vpc_file_ptr, vpc_file_size, ACL_MEMCPY_DEVICE_TO_DEVICE)

## 6.3 构造存放输出图片信息的字典。
multithreading_count = 1
crop_region_infos = []
for i in range(multithreading_count):
    output_pic = &#123;'picture_width': 960,
                  'picture_height': 540,
                  'picture_width_stride': 960,
                  'picture_height_stride': 540,
                  'picture_format': HI_PIXEL_FORMAT_YUV_SEMIPLANAR_420&#125;
    output_pic["picture_buffer_size"] = output_pic["picture_width_stride"] * output_pic["picture_height_stride"] * 3 // 2
    picture_address, ret = acl.himpi.dvpp_malloc(0, output_pic["picture_buffer_size"])
    output_pic["picture_address"] = picture_address

    ret = acl.rt.memset(output_pic["picture_address"], output_pic["picture_buffer_size"], 0, output_pic["picture_buffer_size"])
    crop_region = &#123;'top_offset': 0, 'left_offset': 0, 'crop_width': 960, 'crop_height': 540&#125;
    crop_region_info = &#123;'dest_pic_info': output_pic, 'crop_region': crop_region&#125;
    crop_region_infos.append(crop_region_info)

## 6.4 调用抠图接口。
task_id, ret = acl.himpi.vpc_crop(channel_id, input_pic, crop_region_infos, 1, -1)

## 6.5 等待任务处理结束，任务处理结束后，输出图片数据在outputPic.picture_address指向的内存中。
ret = acl.himpi.vpc_get_process_result(channel_id, task_id, -1)

## 6.6 如果运行模式为ACL_HOST，且Host上需要展示VPC输出的图片数据，则需要申请Host内存，通过acl.rt.memcpy接口将Device的输出图片数据传输到Host；如果Host上不需要展示VPC输出的图片数据，则VPC的输出图片数据可以直接作为模型推理的输入。
## 6.6 VPC的输出图片数据可以直接作为模型推理的输入。
if run_mode == ACL_HOST:
    np_output = np.zeros(output_pic.get('picture_buffer_size'), dtype=np.byte)
    
    bytes_data = np_output.tobytes()
    np_output_ptr = acl.util.bytes_to_ptr(bytes_data)
    ret = acl.rt.memcpy(np_output_ptr, output_pic.get('picture_buffer_size'), output_pic.get("picture_address"),
                        output_pic.get('picture_buffer_size'), ACL_MEMCPY_DEVICE_TO_HOST)
    # ......
else
    # 可以直接使用VPC的输出图片数据，在outputPic.picture_address指向的内存中。
    # ......
&#125;

## 6.7 释放输入、输出内存。
ret = acl.himpi.dvpp_free(input_pic['picture_address'])
ret = acl.himpi.dvpp_free(output_pic['picture_address']))

## 7.销毁通道。
ret = acl.himpi.vpc_destroy_chn(channel_id)

## 8. 媒体数据处理系统去初始化。
ret = acl.himpi.sys_exit()

## 9. 释放运行管理资源(依次释放Context、Device)。
ret = acl.rt.destroy_context(context)
ret = acl.rt.reset_device(0)

## 10.pyACL去初始化。
ret = acl.finalize()

父主题： 媒体数据处理V2

JPEGD图片解码

JPEGD（JPEG Decoder）负责完成图像解码功能，将.jpg、.jpeg、.JPG、.JPEG图片解码成YUV格式图片。关于JPEGD功能的详细介绍及约束请参见JPEGD功能及约束说明。

本节介绍JPEGD图片解码的接口调用流程，同时配合示例代码辅助理解该接口调用流程。

接口调用流程

开发应用时，如果涉及对JPEG图片的解码，则应用程序中必须包含解码的代码逻辑，关于图片解码的接口调用流程，请先参见pyACL接口调用流程了解整体流程，再查看本节中的流程说明。

图1 接口调用的流程

当前系统支持解码JPEG图片，关键接口的说明如下：

调用acl.himpi.sys_init接口进行媒体数据处理系统初始化。
调用acl.himpi.vdec_create_chn接口创建通道。
调用acl.himpi.dvpp_malloc接口申请Device上的内存，存放输入或输出数据。
解码前，需调用acl.himpi.vdec_start_recv_stream接口通知解码器启动接收码流，再调用acl.himpi.vdec_send_stream接口发送解码码流，acl.himpi.vdec_send_stream接口是异步接口，调用该接口仅表示任务下发成功，还需要调acl.himpi.vdec_get_frame接口获取解码结果数据，成功获取解码数据后，可以调用acl.himpi.vdec_release_frame接口释放帧相关的资源。

解码结束后，需调用acl.himpi.vdec_stop_recv_stream接口通知解码器停止接收码流。
调用acl.himpi.dvpp_free接口释放输入、输出内存。
调用acl.himpi.vdec_destroy_chn接口销毁通道。
调用acl.himpi.sys_exit接口进行媒体数据处理系统去初始化。

示例代码

调用接口后，需增加异常处理的分支，并记录报错日志、提示日志，此处不一一列举。以下是关键步骤的代码示例，不可以直接拷贝运行，仅供参考。

## 1.获取软件栈的运行模式，不同运行模式影响后续的接口调用流程（例如是否进行数据传输等）。
run_mode, ret = acl.rt.get_run_mode()

## 2.pyACL 初始化。
ret = acl.init()

## 3.运行管理资源申请(依次申请Device、Context)。
ret = acl.rt.set_device(0)
context, ret = acl.rt.create_context(0)

## 4.初始化媒体数据处理系统。
ret = acl.himpi.sys_init()

## 5.创建通道。
channel_id = 0
attr = &#123;'type': HI_PT_JPEG, 'mode': HI_VDEC_SEND_MODE_FRAME,
        'pic_width': 1920, 'pic_height': 1080,
        'stream_buf_size': 1920 * 1080, 'frame_buf_size': 0,
        'frame_buf_cnt': 9&#125;

ret = acl.himpi.vdec_create_chn(channel_id, attr)
## 6.设置通道属性。
jpegd_param_dict, ret = acl.himpi.vdec_get_chn_param(channel_id)
jpegd_param_dict["pic_param"]["pixel_format"] = HI_PIXEL_FORMAT_YUV_SEMIPLANAR_420
jpegd_param_dict["pic_param"]["alpha"] = 255
jpegd_param_dict["display_frame_num"] = 0
ret = acl.himpi.vdec_set_chn_param(i, jpegd_param_dict)

## 7.解码器启动接收码流。
ret = acl.himpi.vdec_start_recv_stream(channel_id)

## 8.发送码流。
## 8.1 申请输入内存。
## input_size表示输入图片占用的内存大小，此处以1024 Byte为例，用户需根据实际情况计算内存大小。
input_size = 1024;
input_addr, ret = acl.himpi.dvpp_malloc(0, input_size);

#如果运行模式为ACL_HOST，则需要申请Host内存，将输入图片数据读入Host内存，再通过acl.rt.memcpy接口将Host的图片数据传输到Device，数据传输完成后，需及时释放Host内存；否则直接将输入图片数据读入Device内存。
#直接将输入图片数据读入Device内存。
if run_mode == ACL_HOST:
    # 申请Host内存。
    input_buffer, ret= acl.rt.malloc_host(input_size)
    # 将输入图片读入内存中。
    vdec_file = np.fromfile(vdec_file_path, dtype=np.byte)
    vdec_file_size = vdec_file.itemsize * vdec_file.size
    
    bytes_data = vdec_file.tobytes()
    vdec_file_ptr = acl.util.bytes_to_ptr(bytes_data)
    # 数据传输。
    ret = acl.rt.memcpy(input_addr, input_size, vdec_file_ptr, vdec_file_size, ACL_MEMCPY_HOST_TO_DEVICE)
else:
    # 将输入图片读入内存中。
    vdec_file = np.fromfile(vdec_file_path, dtype=np.byte)
    vdec_file_size = vdec_file.itemsize * vdec_file.size
    
    bytes_data = vdec_file.tobytes()
    vdec_file_ptr = acl.util.bytes_to_ptr(bytes_data)
    # 数据传输。
    ret = acl.rt.memcpy(input_addr, input_size, vdec_file_ptr, vdec_file_size, ACL_MEMCPY_DEVICE_TO_DEVICE)

## 8.2 构造存放输入图片信息的字典。
stream = &#123;'end_of_frame': HI_TRUE, 'end_of_stream': HI_FALSE,
          'need_display': HI_TRUE, 'pts': 0,
          'len': input_size, 'addr': vdec_file_ptr&#125;
img_info, ret = acl.himpi.dvpp_get_image_info(HI_PT_JPEG, stream)
if run_mode == ACL_HOST:
    # 如果不使用Host上的数据，需及时释放。
    ret = acl.rt.free_host(input_buffer)

stream['addr'] =  input_addr

## 8.3 构造存放输出图片信息的字典，并申请输出内存。
out_pic_info = &#123;"width": img_info['width'],
                "height": img_info['height'],
                "width_stride": img_info['width_stride'],
                "height_stride": img_info['height_stride'],
                "pixel_format": HI_PIXEL_FORMAT_UNKNOWN,
                "buffer_size": img_info['img_buf_size']&#125;
out_buffer, ret = acl.himpi.dvpp_malloc(0, out_pic_info['buffer_size'])
out_pic_info['vir_addr '] = out_buffer

## 8.4 发送需解码的输入图片。
ret = acl.himpi.vdec_send_stream(channel_id, stream, out_pic_info, 0)

## 9.接收解码结果。
## 9.1 获取解码结果。
frame_info, supplement, stream, ret = acl.himpi.vdec_get_frame(channel_id, 0)
if ret == 0:
    dec_result = frame_info['v_frame']['frame_flag']
    if dec_result == 0: #  0: Decode success
        print("Chn %u GetFrame Success, Decode Success \n"%channel_id)
    else: # Decode fail
        print("Chn %u GetFrame Success, Decode Fail \n"%channel_id)

## 9.2 如果运行模式为ACL_HOST，且Host上需要展示JPEGD输出的图片数据，则需要申请Host内存，通过aclrtMemcpy接口将Device的输出图片数据传输到Host。
## 9.2 获取JPEGD的输出图片数据。

if run_mode == ACL_HOST:
    # 申请Host内存。
    output_buffer, ret= acl.rt.malloc_host(out_pic_info['buffer_size'])
    # 数据传输。
    ret = acl.rt.memcpy(output_buffer, out_pic_info['buffer_size'], frame_info['v_frame']['virt_addr'][0], out_pic_info['buffer_size'], ACL_MEMCPY_DEVICE_TO_HOST)

    # ......
    # 数据使用完成后，及时释放不使用的内存。
    ret = acl.rt.free_host(output_buffer)
else:
    # 可以直接使用JPEGD的输出图片数据，在outputPic.picture_address指向的内存中。
    # ......

## 9.3 释放输入、输出内存。
ret = acl.himpi.dvpp_free(frame_info['v_frame']['virt_addr'][0])
ret = acl.himpi.dvpp_free(stream['addr'])

## 9.4 释放资源。
ret = acl.himpi.vdec_release_frame(channel_id, frame_info)

## 10.解码器停止接收码流。
ret = acl.himpi.vdec_stop_recv_stream(channel_id)

## 7.销毁通道。
ret = acl.himpi.vdec_destroy_chn(channel_id)

## 8. 媒体数据处理系统去初始化。
ret = acl.himpi.sys_exit()

## 9. 释放运行管理资源(依次释放Context、Device)。
ret = acl.rt.destroy_context(context)
ret = acl.rt.reset_device(0)

## 10.pyACL去初始化。
ret = acl.finalize()

父主题： 媒体数据处理V2

在线提单