• 在ffmpeg上实现libhevc wrapper

    一 都说android集成了libhevc用来做h265软解码，因为性能比较好。我自己在x86上测试了一下，估计是libhevc 实现的x86 SIMD不太好，速度只有ffmpeg里面openhec的20%左右。

    二 先在ffmpeg里面实现wrapper给android端同学用用。

    三 libhevc全都是操作结构体的方式调用的，其实用起来不是很方便。尤其是出错了，也不知道啥原因，需要一步步debug。 libhevc自己的demo，是结合了display的，不能作为参考，因为集成到ffmpeg里面也不需要display。

    四 libhevc解码步骤

    4.1 创建对象

    4.2 设置解码核个数

     4.3 设置CPU类型

    这里，因为我要用在手机上，所以默认设置的ARM_NEON

    4.4 解码器设置为解码参数头模式

     4.5 解码参数头，vps，sps，pps

    4.6 把解码器设置为解码帧模式

     4.7 解码视频帧

     总结：大概就是分上面7个步骤，值得注意的时候，有时候输入的视频帧是hvcc格式的，有时候是annexb格式的。但是libhevc只能解码annexb格式的，所以需要转换下。另外解码出来的视频帧是yuv420sp_uv格式的，我们常用的是yuv420p格式的，这个我们需要转换下。

    上代码：

    1. #include <unistd.h>
    2. #include <fcntl.h>
    3. #include <sys/types.h>
    4.  
    5. #include "libavutil/avassert.h"
    6. #include "libavutil/cpu.h"
    7. #include "libavutil/film_grain_params.h"
    8. #include "libavutil/mastering_display_metadata.h"
    9. #include "libavutil/imgutils.h"
    10. #include "libavutil/opt.h"
    11.  
    12. #include "hevc_parse.h"
    13. #include "avcodec.h"
    14. #include "bytestream.h"
    15. #include "codec_internal.h"
    16. #include "decode.h"
    17. #include "internal.h"
    18. #include "ihevc_typedefs.h"
    19. #include "iv.h"
    20. #include "ivd.h"
    21. #include "ihevcd_cxa.h"
    22. #include "ithread.h"
    23. #include "ihevcd_error.h"
    24. #include "bsf.h"
    25.  
    26. #define ALIGN8(x) ((((x) + 7) >> 3) << 3)
    27. #define NUM_DISPLAY_BUFFERS 4
    28. #define DEFAULT_FPS         30
    29.  
    30. #define ENABLE_DEGRADE 0
    31. #define MAX_DISP_BUFFERS    64
    32. #define EXTRA_DISP_BUFFERS  0
    33. #define STRLENGTH 1000
    34.  
    35. #define ADAPTIVE_TEST
    36. #define ADAPTIVE_MAX_WD 8192
    37. #define ADAPTIVE_MAX_HT 4096
    38. //#define TEST_FLUSH
    39. #define FLUSH_FRM_CNT 100
    40.  
    41. #define PEAK_WINDOW_SIZE            8
    42. #define DEFAULT_SHARE_DISPLAY_BUF   0
    43. #define STRIDE                      0
    44. #define DEFAULT_NUM_CORES           2
    45.  
    46. #define DUMP_SINGLE_BUF 0
    47. #define IV_ISFATALERROR(x)         (((x) >> IVD_FATALERROR) & 0x1)
    48.  
    49. #define ivd_cxa_api_function        ihevcd_cxa_api_function
    50. #define INIT_INVALID_PTS  (-500000)
    51. typedef struct
    52. {
    53.     UWORD32 u4_piclen_flag;
    54.     UWORD32 u4_file_save_flag;
    55.     UWORD32 u4_chksum_save_flag;
    56.     IV_COLOR_FORMAT_T e_output_chroma_format;
    57.     IVD_ARCH_T e_arch;
    58.     IVD_SOC_T e_soc;
    59.     UWORD32 dump_q_rd_idx;
    60.     UWORD32 dump_q_wr_idx;
    61.     WORD32  disp_q_wr_idx;
    62.     WORD32  disp_q_rd_idx;
    63.  
    64.     void *cocodec_obj;
    65.     UWORD32 share_disp_buf;
    66.     UWORD32 num_disp_buf;
    67.     UWORD32 b_pic_present;
    68.     WORD32 i4_degrade_type;
    69.     WORD32 i4_degrade_pics;
    70.     UWORD32 u4_num_cores;
    71.     UWORD32 disp_delay;
    72.     WORD32 trace_enable;
    73.     CHAR ac_trace_fname[STRLENGTH];
    74.     CHAR ac_piclen_fname[STRLENGTH];
    75.     CHAR ac_ip_fname[STRLENGTH];
    76.     CHAR ac_op_fname[STRLENGTH];
    77.     CHAR ac_op_chksum_fname[STRLENGTH];
    78.     ivd_out_bufdesc_t s_disp_buffers[MAX_DISP_BUFFERS];
    79.     iv_yuv_buf_t s_disp_frm_queue[MAX_DISP_BUFFERS];
    80.     UWORD32 s_disp_frm_id_queue[MAX_DISP_BUFFERS];
    81.     UWORD32 loopback;
    82.     UWORD32 display;
    83.     UWORD32 full_screen;
    84.     UWORD32 fps;
    85.     UWORD32 max_wd;
    86.     UWORD32 max_ht;
    87.     UWORD32 max_level;
    88.  
    89.     UWORD32 u4_strd;
    90.  
    91.     /* For signalling to display thread */
    92.     UWORD32 u4_pic_wd;
    93.     UWORD32 u4_pic_ht;
    94.  
    95.     /* For IOS diplay */
    96.     WORD32 i4_screen_wd;
    97.     WORD32 i4_screen_ht;
    98.  
    99.     //UWORD32 u4_output_present;
    100.     WORD32  quit;
    101.     WORD32  paused;
    102.     WORD32  last_gebuf_index;    
    103.  
    104.     void *pv_disp_ctx;
    105.     void *display_thread_handle;
    106.     WORD32 display_thread_created;
    107.     volatile WORD32 display_init_done;
    108.     volatile WORD32 display_deinit_flag;
    109.  
    110.     IV_COLOR_FORMAT_T (*get_color_fmt)(void);
    111.     UWORD32 (*get_stride)(void);
    112. } vid_dec_ctx_t;
    113.  
    114. typedef struct LibhevcdecContext {
    115.     AVClass *class;
    116.     /* This packet coincides with AVCodecInternal.in_pkt
    117.      * and if not owned by us. */
    118.     AVBufferPool *pool;
    119.     int pool_size;
    120.     int tile_threads;
    121.     int num_cores;
    122.     int apply_grain;
    123.     char *cpu_simd;
    124.     int operating_point;
    125.     int all_layers;
    126.     vid_dec_ctx_t s_app_ctx;
    127.     int inited;
    128.     ivd_out_bufdesc_t *ps_out_buf;
    129.     const AVBitStreamFilter *hevcbsfc;
    130.     AVBSFContext *bsf_context;
    131.     int last_max_timestamp;
    132.     int last_duration;
    133. } LibhevcdecContext;
    135. #define HEVCDEC_PIXEL_LAYOUT_I400 0
    136. #define HEVCDEC_PIXEL_LAYOUT_I420 1
    137. #define HEVCDEC_PIXEL_LAYOUT_I422 2
    138. #define HEVCDEC_PIXEL_LAYOUT_I444 3
    139. static const uint8_t libhevc_startcode[4] = {0x00, 0x00, 0x00, 0x01};
    140. static const enum AVPixelFormat pix_fmt[][3] = {
    141.     [HEVCDEC_PIXEL_LAYOUT_I400] = { AV_PIX_FMT_GRAY8,   AV_PIX_FMT_GRAY10,    AV_PIX_FMT_GRAY12 },
    142.     [HEVCDEC_PIXEL_LAYOUT_I420] = { AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV420P12 },
    143.     [HEVCDEC_PIXEL_LAYOUT_I422] = { AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV422P12 },
    144.     [HEVCDEC_PIXEL_LAYOUT_I444] = { AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUV444P10, AV_PIX_FMT_YUV444P12 },
    145. };
    146.  
    147. static const enum AVPixelFormat pix_fmt_rgb[3] = {
    148.     AV_PIX_FMT_GBRP, AV_PIX_FMT_GBRP10, AV_PIX_FMT_GBRP12,
    149. };
    150.  
    151.  
    152. static UWORD32 default_get_stride(void)
    153. {
    154.     return 0;
    155. }
    156.  
    157. static IV_COLOR_FORMAT_T default_get_color_fmt(void)
    158. {
    159.     return IV_YUV_420P;
    160. }
    161.  
    162. static void * _aligned_malloc(int32_t size, int32_t alignment)
    163. {
    164.     int32_t alignsize = (size + alignment - 1)/alignment * alignment;
    165.     return malloc(alignsize);
    166. }
    167.  
    168. static void _aligned_free(void *pv_buf)
    169. {
    170.     if (pv_buf) {
    171.         free(pv_buf);
    172.     }
    173. }
    174.  
    175. static void *ihevca_aligned_malloc(void *pv_ctxt, WORD32 alignment, WORD32 i4_size)
    176. {
    177.     (void)pv_ctxt;
    178.     return (void *)_aligned_malloc(i4_size, alignment);
    179. }
    180.  
    181. static void ihevca_aligned_free(void *pv_ctxt, void *pv_buf)
    182. {
    183.     (void)pv_ctxt;
    184.     _aligned_free(pv_buf);
    185.     return;
    186. }
    187.  
    188. static int libhevcdec_init_bsf(AVCodecContext *c)
    189. {
    190.     LibhevcdecContext *libhevc = (LibhevcdecContext*)c->priv_data;	
    191.     /*
    192.      *init hevc bitstream filter
    193.      * */
    194.     libhevc->hevcbsfc = av_bsf_get_by_name("hevc_mp4toannexb");
    195.     if (libhevc->hevcbsfc == NULL) {
    196.         av_log(c, AV_LOG_ERROR, "libhevc av_bitstream_filter_init  failed.");
    197.         return -4;
    198.     }
    199.     if (av_bsf_alloc(libhevc->hevcbsfc, &libhevc->bsf_context) != 0) {
    200.         av_log(c, AV_LOG_ERROR, "libhevc av_bsf_alloc  failed.");
    201.         return -5;
    202.     }
    203.  
    204.     if (avcodec_parameters_from_context(libhevc->bsf_context->par_in, c) != 0) {
    205.         av_log(c, AV_LOG_ERROR, "libhevc avcodec_parameters_from_context  failed.");
    206.         return -6;
    207.     }
    208.     libhevc->bsf_context->time_base_in = c->time_base;
    209.     av_bsf_init(libhevc->bsf_context);
    210.     return 0;
    211. }
    212.  
    213. static av_cold int libhevcdec_init(AVCodecContext *c)
    214. {
    215.     LibhevcdecContext *libhevc = (LibhevcdecContext*)c->priv_data;
    216. /*
    217.  *    int pool_size;
    218.     int tile_threads;
    219.     int num_cores;
    220.     int apply_grain;
    221.     int operating_point;
    222.     int all_layers;
    223.  * */
    224.     int ret;
    225.     strcpy(libhevc->s_app_ctx.ac_ip_fname, "\0");
    226.     libhevc->s_app_ctx.dump_q_wr_idx = 0;
    227.     libhevc->s_app_ctx.dump_q_rd_idx = 0;
    228.     libhevc->s_app_ctx.display_thread_created = 0;
    229.     libhevc->s_app_ctx.disp_q_wr_idx = 0;
    230.     libhevc->s_app_ctx.disp_q_rd_idx = 0;
    231.     libhevc->s_app_ctx.disp_delay = 0;
    232.     libhevc->s_app_ctx.loopback = 0;
    233.     libhevc->s_app_ctx.display = 0;
    234.     libhevc->s_app_ctx.full_screen = 0;
    235.     libhevc->s_app_ctx.u4_piclen_flag = 0;
    236.     libhevc->s_app_ctx.fps = DEFAULT_FPS;
    237.     libhevc->s_app_ctx.share_disp_buf = 0;//DEFAULT_SHARE_DISPLAY_BUF;
    238.     libhevc->s_app_ctx.u4_num_cores = DEFAULT_NUM_CORES;
    239.     libhevc->s_app_ctx.i4_degrade_type = 0;
    240.     libhevc->s_app_ctx.i4_degrade_pics = 0;
    241.     libhevc->s_app_ctx.e_arch = ARCH_ARM_A9Q;
    242.     libhevc->s_app_ctx.e_soc = SOC_GENERIC;
    243.     libhevc->s_app_ctx.u4_strd = STRIDE;
    244.     libhevc->s_app_ctx.display_thread_handle           = malloc(ithread_get_handle_size());
    245.     libhevc->s_app_ctx.quit          = 0;
    246.     libhevc->s_app_ctx.paused        = 0;
    247.     libhevc->s_app_ctx.get_stride = &default_get_stride;
    248.     libhevc->s_app_ctx.get_color_fmt = &default_get_color_fmt;
    249.     libhevc->s_app_ctx.display_deinit_flag = 0;
    250.     libhevc->s_app_ctx.e_output_chroma_format = IV_YUV_420SP_UV;
    251.     libhevc->inited = 0;
    252.     libhevc->bsf_context = NULL;
    253.     libhevc->last_max_timestamp = INIT_INVALID_PTS;
    254.     libhevc->last_duration = 40;//default 25fps
    255.     libhevc->ps_out_buf = (ivd_out_bufdesc_t *)malloc(sizeof(ivd_out_bufdesc_t));
    256.     memset(libhevc->ps_out_buf, 0x0, sizeof(ivd_out_bufdesc_t));
    257.     libhevc->ps_out_buf->u4_num_bufs = 3;
    258.     /*
    259.      *create decode instance 
    260.      * */
    261.     ihevcd_cxa_create_ip_t s_create_ip;
    262.     ihevcd_cxa_create_op_t s_create_op;
    263.     void *fxns = &ivd_cxa_api_function;
    264.  
    265.     s_create_ip.s_ivd_create_ip_t.e_cmd = IVD_CMD_CREATE;
    266.     s_create_ip.s_ivd_create_ip_t.u4_share_disp_buf = libhevc->s_app_ctx.share_disp_buf;
    267.     s_create_ip.s_ivd_create_ip_t.e_output_format = (IV_COLOR_FORMAT_T)libhevc->s_app_ctx.e_output_chroma_format;
    268.     s_create_ip.s_ivd_create_ip_t.pf_aligned_alloc = ihevca_aligned_malloc;
    269.     s_create_ip.s_ivd_create_ip_t.pf_aligned_free = ihevca_aligned_free;
    270.     s_create_ip.s_ivd_create_ip_t.pv_mem_ctxt = NULL;
    271.     s_create_ip.s_ivd_create_ip_t.u4_size = sizeof(ihevcd_cxa_create_ip_t);
    272.     s_create_op.s_ivd_create_op_t.u4_size = sizeof(ihevcd_cxa_create_op_t);
    273.     ret = ivd_cxa_api_function(NULL, (void *)&s_create_ip,
    274.                                        (void *)&s_create_op);
    275.     if (ret != IV_SUCCESS) {
    276.         av_log(c, AV_LOG_ERROR, "libhevc decoder open created failed.");        
    277. 	return -1;
    278.     }
    279.     iv_obj_t *codec_obj = (iv_obj_t*)s_create_op.s_ivd_create_op_t.pv_handle;
    280.     codec_obj->pv_fxns = fxns;
    281.     codec_obj->u4_size = sizeof(iv_obj_t);
    282.     libhevc->s_app_ctx.cocodec_obj = codec_obj; //set code object here ############################
    283.     /*
    284.      * set num of cores
    285.     */
    286.     ihevcd_cxa_ctl_set_num_cores_ip_t s_ctl_set_cores_ip;
    287.     ihevcd_cxa_ctl_set_num_cores_op_t s_ctl_set_cores_op;
    288.  
    289.     s_ctl_set_cores_ip.e_cmd = IVD_CMD_VIDEO_CTL;
    290.     s_ctl_set_cores_ip.e_sub_cmd = (IVD_CONTROL_API_COMMAND_TYPE_T)IHEVCD_CXA_CMD_CTL_SET_NUM_CORES;
    291.     s_ctl_set_cores_ip.u4_num_cores = libhevc->s_app_ctx.u4_num_cores;
    292.     s_ctl_set_cores_ip.u4_size = sizeof(ihevcd_cxa_ctl_set_num_cores_ip_t);
    293.     s_ctl_set_cores_op.u4_size = sizeof(ihevcd_cxa_ctl_set_num_cores_op_t);
    294.     ret = ivd_cxa_api_function((iv_obj_t *)codec_obj, (void *)&s_ctl_set_cores_ip,
    295.                                    (void *)&s_ctl_set_cores_op);
    296.     if (ret != IV_SUCCESS) {
    297.         av_log(c, AV_LOG_ERROR, "libhevc decoder set cores failed.");     
    298.         return -2; 
    299.     }
    300.     /*
    301.      *set processor type
    302.      * */
    303.     ihevcd_cxa_ctl_set_processor_ip_t s_ctl_set_num_processor_ip;
    304.     ihevcd_cxa_ctl_set_processor_op_t s_ctl_set_num_processor_op;
    305.  
    306.     s_ctl_set_num_processor_ip.e_cmd = IVD_CMD_VIDEO_CTL;
    307.     s_ctl_set_num_processor_ip.e_sub_cmd = (IVD_CONTROL_API_COMMAND_TYPE_T)IHEVCD_CXA_CMD_CTL_SET_PROCESSOR;
    308.     s_ctl_set_num_processor_ip.u4_arch = libhevc->s_app_ctx.e_arch;
    309.     s_ctl_set_num_processor_ip.u4_soc = libhevc->s_app_ctx.e_soc;
    310.     s_ctl_set_num_processor_ip.u4_size = sizeof(ihevcd_cxa_ctl_set_processor_ip_t);
    311.     s_ctl_set_num_processor_op.u4_size = sizeof(ihevcd_cxa_ctl_set_processor_op_t);
    312.  
    313.     ret = ivd_cxa_api_function((iv_obj_t *)codec_obj, (void *)&s_ctl_set_num_processor_ip,
    314.                                    (void *)&s_ctl_set_num_processor_op);
    315.     if (ret != IV_SUCCESS) {
    316.         av_log(c, AV_LOG_ERROR, "libhevc decoder set processor type failed.");
    317.         return -3;	
    318.     }
    319.  
    320.     return 0;	
    321. }
    322.  
    323. static void libhevcdec_flush(AVCodecContext *c)
    324. {
    325. #if 0
    326.     Libdav1dContext *dav1d = c->priv_data;
    327.  
    328.     dav1d_data_unref(&dav1d->data);
    329.     dav1d_flush(dav1d->c);
    330. #endif
    331. }
    332.  
    333.  
    334.  
    335. static int libhevcdec_fill_frame_withbuf(AVCodecContext *c, AVFrame *frame, ivd_video_decode_op_t *s_video_decode_frame_op, 
    336. 		ivd_video_decode_ip_t *s_video_decode_frame_ip)
    337. {
    338.     LibhevcdecContext *libhevc = (LibhevcdecContext*)c->priv_data;	
    339.     frame->width = c->width;
    340.     frame->height = c->height;
    341.     frame->format = AV_PIX_FMT_YUV420P;
    342.     if (libhevc->last_max_timestamp == INIT_INVALID_PTS) {
    343.         libhevc->last_max_timestamp = s_video_decode_frame_op->u4_ts;
    344.     } else {
    345.         if (libhevc->last_max_timestamp >= s_video_decode_frame_op->u4_ts
    346. 			|| (s_video_decode_frame_op->u4_ts - libhevc->last_max_timestamp < libhevc->last_duration)) {
    347. 	    libhevc->last_max_timestamp += libhevc->last_duration;
    348. 	} else {
    349. 	    libhevc->last_max_timestamp = s_video_decode_frame_op->u4_ts;
    350. 	} 
    351.     }
    352.     frame->pts = libhevc->last_max_timestamp;   
    353.     frame->pkt_dts = libhevc->last_max_timestamp;
    354.     if (av_frame_get_buffer(frame, 16) != 0) {
    355.         av_log(c, AV_LOG_ERROR, "decode get AVFrame buffer failed.");    
    356.         return -14;
    357.     }
    358.     if (s_video_decode_frame_op->e_pic_type == IV_I_FRAME 
    359. 		    || s_video_decode_frame_op->e_pic_type == IV_IDR_FRAME) {
    360.         frame->pict_type = AV_PICTURE_TYPE_I;
    361. 	frame->key_frame = 1;
    362.     } else if (s_video_decode_frame_op->e_pic_type == IV_P_FRAME ||
    363. 		    s_video_decode_frame_op->e_pic_type == IV_IP_FRAME ||
    364. 		    s_video_decode_frame_op->e_pic_type == IV_PP_FRAME) {
    365.         frame->pict_type = AV_PICTURE_TYPE_P;
    366.     } else {
    367.         frame->pict_type = AV_PICTURE_TYPE_B;
    368.     }
    369.  
    370.     if (s_video_decode_frame_op->e_output_format == IV_YUV_420P) {
    371.         /*
    372. 	 *copy y
    373. 	 * */
    374. 	for (int i = 0; i < c->height; i++) {
    375. 	    UWORD8 *ybuf = (UWORD8*)s_video_decode_frame_op->s_disp_frm_buf.pv_y_buf;
    376.             memcpy(frame->data[0] + i * frame->linesize[0], ybuf + i * s_video_decode_frame_op->s_disp_frm_buf.u4_y_strd, c->width);
    377. 	}
    378. 	/*
    379. 	 *copy u
    380. 	 * */
    381. 	for (int i = 0; i < c->height/2; i++) {
    382.             UWORD8 *ubuf = (UWORD8*)s_video_decode_frame_op->s_disp_frm_buf.pv_u_buf;		
    383. 	    UWORD8 *vbuf = (UWORD8*)s_video_decode_frame_op->s_disp_frm_buf.pv_v_buf;
    384. 	    memcpy(frame->data[1] + i * frame->linesize[1], ubuf + i * s_video_decode_frame_op->s_disp_frm_buf.u4_u_strd, c->width/2);
    385. 	    memcpy(frame->data[2] + i * frame->linesize[2], vbuf + i * s_video_decode_frame_op->s_disp_frm_buf.u4_v_strd, c->width/2);
    386. 	}
    387.     } else if (s_video_decode_frame_op->e_output_format == IV_YUV_420SP_UV) {
    388.         /*
    389.          *copy y
    390.          * */
    391.         for (int i = 0; i < c->height; i++) {
    392.             UWORD8 *ybuf = (UWORD8*)s_video_decode_frame_op->s_disp_frm_buf.pv_y_buf;		
    393.             memcpy(frame->data[0] + i * frame->linesize[0], (uint8_t*)ybuf + i * s_video_decode_frame_op->s_disp_frm_buf.u4_y_strd, c->width);
    394.         }
    395.         /*
    396.          *copy u v
    397.          * */
    398. 	for (int i = 0; i < c->height/2; i++) {
    399.             for (int j = 0; j < c->width/2; j++) {
    400. 		UWORD8 *ubuf = (UWORD8*)s_video_decode_frame_op->s_disp_frm_buf.pv_u_buf;    
    401. 		int index = i * s_video_decode_frame_op->s_disp_frm_buf.u4_u_strd + j * 2;
    402. 	        frame->data[1][i * frame->linesize[1] + j] = ubuf[index];
    403. 		frame->data[2][i * frame->linesize[2] + j] = ubuf[index + 1];
    404. 	    }
    405. 	}
    406.         
    407.     } else if (s_video_decode_frame_op->e_output_format == IV_YUV_420SP_VU) {
    408.         /*
    409.          *copy y
    410.          * */
    411.         for (int i = 0; i < c->height; i++) {
    412. 	    UWORD8 *ybuf = (UWORD8*)s_video_decode_frame_op->s_disp_frm_buf.pv_y_buf;	
    413.             memcpy(frame->data[0] + i * frame->linesize[0], ybuf + i * s_video_decode_frame_op->s_disp_frm_buf.u4_y_strd, c->width);
    414.         }
    415.         /*
    416.          *copy u v
    417.          * */
    418.         for (int i = 0; i < c->height/2; i++) {
    419.             for (int j = 0; j < c->width/2; j++) {
    420. 		UWORD8 *ubuf = (UWORD8*)s_video_decode_frame_op->s_disp_frm_buf.pv_u_buf;
    421.                 int index = i * s_video_decode_frame_op->s_disp_frm_buf.u4_u_strd + j * 2;
    422.                 frame->data[2][i * frame->linesize[2] + j] = ubuf[index];
    423.                 frame->data[1][i * frame->linesize[1] + j] = ubuf[index + 1];
    424.             }
    425.         }
    426.     }
    427.  
    428.     return 0;
    429. }
    430.  
    431. static uint8_t *writebytes(uint8_t *dst, const uint8_t *src, int len)
    432. {
    433.     memcpy(dst, src, len);
    434.     return dst + len;
    435. }
    436.  
    437. static int libhevcdec_hvcc2annexb(AVCodecContext *c, AVPacket *pkt)
    438. {
    439.     LibhevcdecContext *hevcdec = (LibhevcdecContext *)c->priv_data;  	
    440.     if (av_bsf_send_packet(hevcdec->bsf_context, pkt) < 0){
    441. 	av_log(c, AV_LOG_ERROR, "av_bsf_send_packet faile \n");
    442. 	return -1;
    443.     }
    444.     if (av_bsf_receive_packet(hevcdec->bsf_context, pkt) < 0) {
    445. 	av_log(c, AV_LOG_ERROR, "av_bsf_receive_packet faile \n");
    446. 	return -2;
    447.     }
    448.     return 0;
    449. }
    450.  
    451. static int libhevcdec_make_codechead(AVCodecContext *c, uint8_t **buf)
    452. {
    453. #define MAX_PADDING (256)
    454.     int outlen = c->extradata_size + MAX_PADDING;
    455.     uint8_t *outbuf = (uint8_t*)malloc(outlen);
    456.     uint8_t *tmp = outbuf;
    457.     if (outbuf == NULL) {
    458.         av_log(c, AV_LOG_ERROR, "alloc codec head mem failed..");
    459. 	return -1;
    460.     }    
    461.     HEVCParamSets ps;
    462.     HEVCSEI sei;
    463.     memset(&ps, 0x0, sizeof(HEVCParamSets));
    464.     memset(&sei, 0x0, sizeof(HEVCSEI));
    465.     int is_nalff = 0;
    466.     int nal_length_size = 0;
    467.     int res = ff_hevc_decode_extradata(c->extradata, c->extradata_size, &ps, &sei, &is_nalff, &nal_length_size, 0, 0, c);
    468.     if (res != 0) {
    469.         av_log(c, AV_LOG_ERROR, "parse extra data failed.");
    470.         ff_hevc_ps_uninit(&ps);
    471.         return -3;
    472.     }
    473.     for (int i = 0; i < HEVC_MAX_VPS_COUNT; i++) {
    474.         if (ps.vps_list[i]) {
    475.             HEVCVPS *vps = (HEVCVPS *)ps.vps_list[i]->data;
    476. 	    tmp = writebytes(tmp, libhevc_startcode, 4);
    477.             tmp = writebytes(tmp, vps->data, vps->data_size);  	    
    478. 	}
    479.     }
    480.     for (int i = 0; i < HEVC_MAX_SPS_COUNT; i++) {
    481.         if (ps.sps_list[i]) {
    482. 	    HEVCSPS *sps = (HEVCSPS *)ps.sps_list[i]->data;
    483. 	    tmp = writebytes(tmp, libhevc_startcode, 4);
    484.             tmp = writebytes(tmp, sps->data, sps->data_size);
    485. 	}
    486.     }
    487.  
    488.     for (int i = 0; i < HEVC_MAX_PPS_COUNT; i++) {
    489.         if (ps.pps_list[i]) {
    490.             HEVCPPS *pps = (HEVCPPS *)ps.pps_list[i]->data;
    491.             tmp = writebytes(tmp, libhevc_startcode, 4);
    492.             tmp = writebytes(tmp, pps->data, pps->data_size);
    493.         }
    494.     }
    495.     ff_hevc_ps_uninit(&ps);
    496.     *buf = outbuf;
    497.     return tmp - outbuf;
    498. }
    499.  
    500. static int libhevcdec_receive_frame(AVCodecContext *c, AVFrame *frame)
    501. {
    502.     LibhevcdecContext *hevcdec = (LibhevcdecContext *)c->priv_data;
    503.     uint8_t *disp_outbuf = NULL;
    504.     int outlen = 0;
    505.     int cur_dts = 0;
    506.     AVPacket pkt = { 0 };
    507.     int res = ff_decode_get_packet(c, &pkt);
    508.     if (res < 0 && res != AVERROR_EOF)
    509.        return res;
    510. #define FAIL(value) \
    511.     {\
    512.         pkt.buf = NULL; \
    513.         av_packet_unref(&pkt); \
    514.     	return value; \
    515.     }\
    516. (void)0    
    517. #define SUCCESS() FAIL(0)
    518.     if (pkt.size) {	
    519.         cur_dts = pkt.pts;
    520. 	if (pkt.duration > 0) {
    521. 	    hevcdec->last_duration = pkt.duration;
    522. 	}
    523. 	if (!hevcdec->inited) {
    524. 	    /*
    525. 	     *set into decoder header mode
    526. 	     * */
    527. 	    ivd_ctl_set_config_ip_t s_ctl_ip;
    528.             ivd_ctl_set_config_op_t s_ctl_op;
    529.             s_ctl_ip.u4_disp_wd = 0;
    530.             s_ctl_ip.e_frm_skip_mode = IVD_SKIP_NONE;
    531.             s_ctl_ip.e_frm_out_mode = IVD_DISPLAY_FRAME_OUT;
    532.             s_ctl_ip.e_vid_dec_mode = IVD_DECODE_HEADER;
    533.             s_ctl_ip.e_cmd = IVD_CMD_VIDEO_CTL;
    534.             s_ctl_ip.e_sub_cmd = IVD_CMD_CTL_SETPARAMS;
    535.             s_ctl_ip.u4_size = sizeof(ivd_ctl_set_config_ip_t);
    536.             s_ctl_op.u4_size = sizeof(ivd_ctl_set_config_op_t);
    537.             res = ivd_cxa_api_function((iv_obj_t*)hevcdec->s_app_ctx.cocodec_obj, (void *)&s_ctl_ip,
    538.                                        (void *)&s_ctl_op);
    539.             if (res != IV_SUCCESS) {
    540. 	        av_log(c, AV_LOG_ERROR, "set decode header mode failed.");
    541. 		FAIL(-2);
    542. 	    }	    
    543.             /*
    544. 	     * try deocde header
    545. 	     * */
    546. #if 1
    547.             uint8_t *headbuf = pkt.data;
    548. 	    uint8_t headlen = pkt.size;
    549. 	    uint8_t *codechead = NULL;
    550. 	    if (c->extradata && c->extradata_size > 0) {
    551. 		res = libhevcdec_make_codechead(c, &codechead);
    552. 	        if (res < 0) {
    553. 		    av_log(c, AV_LOG_ERROR, "parse codec head failed.");
    554. 	            if (codechead) av_free(codechead);
    555. 		    FAIL(-10);
    556. 		}
    557.                 headbuf = codechead;
    558. 		headlen = res;
    559. 	    }
    560. #endif
    561. 	    ivd_video_decode_ip_t s_video_decode_ip;
    562.             ivd_video_decode_op_t s_video_decode_op;
    563. 	    s_video_decode_ip.e_cmd = IVD_CMD_VIDEO_DECODE;
    564.             s_video_decode_ip.u4_ts = pkt.pts;
    565.             s_video_decode_ip.pv_stream_buffer = headbuf;
    566.             s_video_decode_ip.u4_num_Bytes = headlen;
    567.             s_video_decode_ip.u4_size = sizeof(ivd_video_decode_ip_t);
    568.             s_video_decode_op.u4_size = sizeof(ivd_video_decode_op_t);
    569.  
    570.             /*****************************************************************************/
    571.             /*   API Call: Header Decode                                                  */
    572.             /*****************************************************************************/
    573.             res = ihevcd_cxa_api_function((iv_obj_t *)hevcdec->s_app_ctx.cocodec_obj, (void *)&s_video_decode_ip,
    574.                                        (void *)&s_video_decode_op);
    575. 	    if (codechead) av_free(codechead);
    576.  
    577. 	    if (res != IV_SUCCESS) {
    578. 	        av_log(c, AV_LOG_ERROR, "decode header failed.");
    579. 		FAIL(-3);
    580. 	    }
    581. 	    c->width = s_video_decode_op.u4_pic_wd;
    582. 	    c->height = s_video_decode_op.u4_pic_ht;
    583.             c->codec_type = AVMEDIA_TYPE_VIDEO;
    584. 	    if (libhevcdec_init_bsf(c) != 0) {
    585. 	        av_log(c, AV_LOG_ERROR, "libhevcdec_init_bsf failed.");
    586.                 FAIL(-13);
    587. 	    }
    588.         
    589. 	    if (libhevcdec_hvcc2annexb(c, &pkt) != 0) {
    590.                 av_log(c, AV_LOG_ERROR, "set decode header mode failed.");
    591.                 FAIL(-1);
    592.             }
    593.             cur_dts = pkt.dts;
    594.  
    595. #define AlignTo(value, align) \
    596. 	    ((value + align - 1)/align * align)
    597. 	    outlen = AlignTo(c->width, 64) * AlignTo(c->height, 64) * 3;
    598.             hevcdec->ps_out_buf->u4_min_out_buf_size[0] = hevcdec->ps_out_buf->u4_min_out_buf_size[1] = 
    599.             hevcdec->ps_out_buf->u4_min_out_buf_size[2] = AlignTo(c->width, 64) * AlignTo(c->height, 64);
    600. 	    
    601. #if 1
    602. 	    /*
    603. 	     *set frame out mode
    604. 	     * */
    605.             ivd_ctl_set_config_ip_t s_ctl_decode_ip;
    606.             ivd_ctl_set_config_op_t s_ctl_decode_op;
    607.             s_ctl_decode_ip.u4_disp_wd = 0;
    608.             s_ctl_decode_ip.e_frm_skip_mode = IVD_SKIP_NONE;
    609.             s_ctl_decode_ip.e_frm_out_mode = IVD_DISPLAY_FRAME_OUT;
    610.             s_ctl_decode_ip.e_vid_dec_mode = IVD_DECODE_FRAME;
    611.             s_ctl_decode_ip.e_cmd = IVD_CMD_VIDEO_CTL;
    612.             s_ctl_decode_ip.e_sub_cmd = IVD_CMD_CTL_SETPARAMS;
    613.             s_ctl_decode_ip.u4_size = sizeof(ivd_ctl_set_config_ip_t);
    614.  
    615.             s_ctl_decode_op.u4_size = sizeof(ivd_ctl_set_config_op_t);
    616.             res = ivd_cxa_api_function((iv_obj_t *)hevcdec->s_app_ctx.cocodec_obj, (void *)&s_ctl_decode_ip, (void *)&s_ctl_decode_op);
    617.             if (IV_SUCCESS != res) {
    618.                 av_log(c, AV_LOG_ERROR, "decode set decode mode failed.");
    619. 		FAIL(-5);
    620. 	    }
    621. #endif
    622. 	    hevcdec->inited = 1;
    623. 	    if (hevcdec->ps_out_buf->pu1_bufs[0] == NULL) {
    624. 	        disp_outbuf = (uint8_t*)malloc(outlen);
    625. 	        hevcdec->ps_out_buf->pu1_bufs[0] = disp_outbuf;
    626.                 hevcdec->ps_out_buf->u4_min_out_buf_size[0] = hevcdec->ps_out_buf->u4_min_out_buf_size[1] = 
    627. 			hevcdec->ps_out_buf->u4_min_out_buf_size[2] = AlignTo(c->width, 64) * AlignTo(c->height, 64);
    628.                 hevcdec->ps_out_buf->pu1_bufs[1] = hevcdec->ps_out_buf->pu1_bufs[0] + AlignTo(c->width, 64) * AlignTo(c->height, 64);
    629. 		hevcdec->ps_out_buf->pu1_bufs[2] = hevcdec->ps_out_buf->pu1_bufs[1] + AlignTo(c->width, 64) * AlignTo(c->height, 64);
    630. 	        hevcdec->ps_out_buf->u4_num_bufs = 3;
    631. 	    }
    632. 	    ivd_video_decode_ip_t s_video_decode_frame_ip;
    633.             ivd_video_decode_op_t s_video_decode_frame_op;
    634.             s_video_decode_frame_ip.e_cmd = IVD_CMD_VIDEO_DECODE;
    635.             s_video_decode_frame_ip.u4_ts = cur_dts;
    636.             s_video_decode_frame_ip.pv_stream_buffer = pkt.data;
    637.             s_video_decode_frame_ip.u4_num_Bytes = pkt.size;
    638.             s_video_decode_frame_ip.u4_size = sizeof(ivd_video_decode_ip_t);
    639.             s_video_decode_frame_ip.s_out_buffer.u4_min_out_buf_size[0] =
    640.                             hevcdec->ps_out_buf->u4_min_out_buf_size[0];
    641.             s_video_decode_frame_ip.s_out_buffer.u4_min_out_buf_size[1] =
    642.                             hevcdec->ps_out_buf->u4_min_out_buf_size[1];
    643.             s_video_decode_frame_ip.s_out_buffer.u4_min_out_buf_size[2] =
    644.                             hevcdec->ps_out_buf->u4_min_out_buf_size[2];
    645.  
    646.             s_video_decode_frame_ip.s_out_buffer.pu1_bufs[0] =
    647.                             hevcdec->ps_out_buf->pu1_bufs[0];
    648.             s_video_decode_frame_ip.s_out_buffer.pu1_bufs[1] =
    649.                             hevcdec->ps_out_buf->pu1_bufs[1];
    650.             s_video_decode_frame_ip.s_out_buffer.pu1_bufs[2] =
    651.                             hevcdec->ps_out_buf->pu1_bufs[2];
    652.             s_video_decode_frame_ip.s_out_buffer.u4_num_bufs =
    653.                             hevcdec->ps_out_buf->u4_num_bufs;
    654.  
    655. 	    s_video_decode_frame_op.s_disp_frm_buf.pv_y_buf = hevcdec->ps_out_buf->pu1_bufs[0];
    656. 	    s_video_decode_frame_op.s_disp_frm_buf.pv_u_buf = hevcdec->ps_out_buf->pu1_bufs[1];
    657. 	    s_video_decode_frame_op.s_disp_frm_buf.pv_v_buf = hevcdec->ps_out_buf->pu1_bufs[2];
    658.  
    659.             s_video_decode_frame_op.u4_size = sizeof(ivd_video_decode_op_t);
    660.             res = ivd_cxa_api_function((iv_obj_t *)hevcdec->s_app_ctx.cocodec_obj, (void *)&s_video_decode_frame_ip,
    661.                                        (void *)&s_video_decode_frame_op);
    662. 	    if (res != IV_SUCCESS) {
    663. 	        av_log(c, AV_LOG_ERROR, "decode key frame failed. error %d.", s_video_decode_op.u4_error_code);
    664. 		FAIL(-4);
    665. 	    }
    666. 	    if (s_video_decode_frame_op.e_output_format != IV_YUV_420P 
    667. 		&& s_video_decode_frame_op.e_output_format != IV_YUV_420SP_UV
    668. 		&& s_video_decode_frame_op.e_output_format != IV_YUV_420SP_VU) {
    669. 	        av_log(c, AV_LOG_ERROR, "decode format not support. format %d.", s_video_decode_frame_op.e_output_format);
    670. 		FAIL(-5);
    671. 	    }
    672.  
    673. 	    if (frame && s_video_decode_op.u4_frame_decoded_flag) {
    674. 	        if (libhevcdec_fill_frame_withbuf(c, frame, &s_video_decode_frame_op, &s_video_decode_frame_ip) != 0) {
    675. 		    av_log(c, AV_LOG_ERROR, "fill frame failed.");
    676. 		    FAIL(-6);
    677. 		}
    678. 	    }
    679. 	    c->pix_fmt = AV_PIX_FMT_YUV420P;
    680. 	    SUCCESS();
    681. 	}
    682.  
    683. 	if (libhevcdec_hvcc2annexb(c, &pkt) != 0) {
    684. 	    av_log(c, AV_LOG_ERROR, "libhevcdec_hvcc2annexb failed.");
    685. 	    FAIL(-15);
    686. 	}
    687.         ivd_video_decode_ip_t s_video_decode_ip;
    688.         ivd_video_decode_op_t s_video_decode_op; 
    689.         s_video_decode_ip.e_cmd = IVD_CMD_VIDEO_DECODE;
    690.         s_video_decode_ip.u4_ts = cur_dts;
    691.     	s_video_decode_ip.pv_stream_buffer = pkt.data;
    692.         s_video_decode_ip.u4_num_Bytes = pkt.size;
    693.         s_video_decode_ip.u4_size = sizeof(ivd_video_decode_ip_t);
    694.         s_video_decode_ip.s_out_buffer.u4_min_out_buf_size[0] =
    695.                             hevcdec->ps_out_buf->u4_min_out_buf_size[0];
    696.         s_video_decode_ip.s_out_buffer.u4_min_out_buf_size[1] =
    697.                             hevcdec->ps_out_buf->u4_min_out_buf_size[1];
    698.         s_video_decode_ip.s_out_buffer.u4_min_out_buf_size[2] =
    699.                             hevcdec->ps_out_buf->u4_min_out_buf_size[2];
    700.  
    701.         s_video_decode_ip.s_out_buffer.pu1_bufs[0] =
    702.                             hevcdec->ps_out_buf->pu1_bufs[0];
    703.         s_video_decode_ip.s_out_buffer.pu1_bufs[1] =
    704.                             hevcdec->ps_out_buf->pu1_bufs[1];
    705.         s_video_decode_ip.s_out_buffer.pu1_bufs[2] =
    706.                             hevcdec->ps_out_buf->pu1_bufs[2];
    707.         s_video_decode_ip.s_out_buffer.u4_num_bufs =
    708.                             hevcdec->ps_out_buf->u4_num_bufs;
    709.         s_video_decode_op.u4_size = sizeof(ivd_video_decode_op_t);
    710. 	res = ivd_cxa_api_function((iv_obj_t *)hevcdec->s_app_ctx.cocodec_obj, (void *)&s_video_decode_ip,
    711.                                        (void *)&s_video_decode_op);
    712. 	if (res != IV_SUCCESS) {
    713.             av_log(c, AV_LOG_ERROR, "Error in video Frame decode : res %x Error %x\n", res,
    714.                        s_video_decode_op.u4_error_code);
    715. 	    FAIL(-8);
    716.         }
    717. 	if (frame && s_video_decode_op.u4_frame_decoded_flag && s_video_decode_op.u4_output_present) {
    718. 	    if (libhevcdec_fill_frame_withbuf(c, frame, &s_video_decode_op, &s_video_decode_ip) != 0) {
    719.                 av_log(c, AV_LOG_ERROR, "fill frame failed.");
    720. 	        FAIL(-9);
    721.             }
    722. 	}
    723.         if (s_video_decode_op.u4_output_present) {
    724.     //        fprintf(stderr, "linesize[%d %d %d] resolution[%dx%d]type[%d]\n", frame->linesize[0], frame->linesize[1], frame->linesize[2], frame->width, frame->height, frame->pict_type);
    725.         }
    726.     }
    727.     SUCCESS();
    728. }
    729.  
    730. static av_cold int libhevcdec_close(AVCodecContext *c)
    731. {
    732.     LibhevcdecContext *libhevc = (LibhevcdecContext*)c->priv_data;
    733.     if (libhevc->ps_out_buf->pu1_bufs[0]) {
    734.         free(libhevc->ps_out_buf->pu1_bufs[0]);
    735.         libhevc->ps_out_buf->pu1_bufs[0] = libhevc->ps_out_buf->pu1_bufs[1] = libhevc->ps_out_buf->pu1_bufs[2] = NULL;
    736.     }
    737.  
    738.     if (libhevc->ps_out_buf) {
    739.         free(libhevc->ps_out_buf);
    740.         libhevc->ps_out_buf = NULL;
    741.     }
    742.  
    743.     if (libhevc->bsf_context) {
    744.         av_bsf_free(&libhevc->bsf_context);
    745.         libhevc->bsf_context = NULL;
    746.     }
    747.     return 0;
    748. }
    749. #define OFFSET(x) offsetof(LibhevcdecContext, x)
    750. #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
    751. static const AVOption hevcdec_options[] = {
    752.     { "numcores", "decode cores", OFFSET(num_cores), AV_OPT_TYPE_INT, { .i64 = 2 }, 0, 16, VD},
    753.     { "cpusimd",        "Set the cpu simd",   OFFSET(cpu_simd),        AV_OPT_TYPE_STRING, { .str = "ARM_NEONINTR" }, 0, 0, VD},
    754.     { NULL }
    755. };
    756.  
    757. static const AVClass libhevcdec_class = {
    758.     .class_name = "libhevcdec",
    759.     .item_name  = av_default_item_name,
    760.     .option     = hevcdec_options,
    761.     .version    = LIBAVUTIL_VERSION_INT,
    762. };
    763.  
    764. const FFCodec ff_libhevcdec_decoder = {
    765.     .p.name         = "libhevcdec",
    766.     .p.long_name    = NULL_IF_CONFIG_SMALL("libhevcdec hevc  decoder by VideoLAN"),
    767.     .p.type         = AVMEDIA_TYPE_VIDEO,
    768.     .p.id           = AV_CODEC_ID_HEVC,
    769.     .priv_data_size = sizeof(LibhevcdecContext),
    770.     .init           = libhevcdec_init,
    771.     .close          = libhevcdec_close,
    772.     .flush          = libhevcdec_flush,
    773.     FF_CODEC_RECEIVE_FRAME_CB(libhevcdec_receive_frame),
    774.     .p.capabilities = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_OTHER_THREADS,
    775.     .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_SETS_PKT_DTS |
    776.                       FF_CODEC_CAP_AUTO_THREADS,
    777.     .p.priv_class   = &libhevcdec_class,
    778.     .p.wrapper_name = "libhevcdec",
    779. };

    参考别的库引入，在configure脚本里面加上配置项，然后configure一下，就能编译了。

     --enable-libhevcdec --enable-libx264 --enable-gpl --extra-cflags='-I/data/decoder/libhevc/decoder -I/data/decoder/libhevc/common' --extra-ldflags='-L /data/decoder/libhevc/build/' --extra-libs='-lhevcdec -ldl -lm' --disable-ffplay

    解码命令示例：

    ./ffmpeg_g -vcodec libhevcdec -vsync 0 -i chiji.mp4 -y 123.yuv

    配置不会可以发邮件,1045056991@qq.com

  • 相关阅读:
    混凝土搅拌站预拌厂数字孪生可视化管理系统，三维可视化数据监控平台
    汇凯金业：黄金5g工艺是什么意思
    Python自学笔记9：实操案例六（千年虫，购物流程）
    NLP模型（二）——GloVe介绍
    网页JS自动化脚本(十)新旧字符串关键词检测
    【数据分类】基于麻雀搜索算法优化支持向量机的数据分类方法 SSA-SVM分类算法【Matlab代码#61】
    创建型-单例模式-实现和优缺点
    1488. 避免洪水泛滥
    【智能优化算法-飞蛾扑火优化算法】基于水循环混合飞蛾扑火优化算法求解约束的工程优化问题附matlab代码WCMFO
    【免费模板】2023数学建模国赛word+latex模板免费分享
  • 原文地址：https://blog.csdn.net/fantasy_ARM9/article/details/125434561