devbox
2023面试高手
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

YUV采样格式存储拷贝及转换_yuv 拷贝

作者：2023面试高手 | 2024-03-06 00:43:20

赞

踩

yuv 拷贝

1.YUV采样格式初始化

  1. /* messy code alarm */
  2. void video_frame_init(struct video_frame *frame, enum video_format format,
  3. 		uint32_t width, uint32_t height)
  4. {
  5. 	size_t size;
  6. 	size_t offsets[MAX_AV_PLANES];
  7. 	int    alignment = base_get_alignment();
  8.  
  9. 	if (!frame) return;
  10.  
  11. 	memset(frame, 0, sizeof(struct video_frame));
  12. 	memset(offsets, 0, sizeof(offsets));
  13.  
  14. 	switch (format) {
  15. 	case VIDEO_FORMAT_NONE:
  16. 		return;
  17.  
  18. 	case VIDEO_FORMAT_I420:
  19. 		size = width * height;
  20. 		ALIGN_SIZE(size, alignment);
  21. 		offsets[0] = size;
  22. 		size += (width/2) * (height/2);
  23. 		ALIGN_SIZE(size, alignment);
  24. 		offsets[1] = size;
  25. 		size += (width/2) * (height/2);
  26. 		ALIGN_SIZE(size, alignment);
  27. 		frame->data[0] = bmalloc(size);
  28. 		frame->data[1] = (uint8_t*)frame->data[0] + offsets[0];
  29. 		frame->data[2] = (uint8_t*)frame->data[0] + offsets[1];
  30. 		frame->linesize[0] = width;
  31. 		frame->linesize[1] = width/2;
  32. 		frame->linesize[2] = width/2;
  33. 		break;
  34.  
  35. 	case VIDEO_FORMAT_NV12:
  36. 		size = width * height;
  37. 		ALIGN_SIZE(size, alignment);
  38. 		offsets[0] = size;
  39. 		size += (width/2) * (height/2) * 2;
  40. 		ALIGN_SIZE(size, alignment);
  41. 		frame->data[0] = bmalloc(size);
  42. 		frame->data[1] = (uint8_t*)frame->data[0] + offsets[0];
  43. 		frame->linesize[0] = width;
  44. 		frame->linesize[1] = width;
  45. 		break;
  46.  
  47. 	case VIDEO_FORMAT_Y800:
  48. 		size = width * height;
  49. 		ALIGN_SIZE(size, alignment);
  50. 		frame->data[0] = bmalloc(size);
  51. 		frame->linesize[0] = width;
  52. 		break;
  53.  
  54. 	case VIDEO_FORMAT_YVYU:
  55. 	case VIDEO_FORMAT_YUY2:
  56. 	case VIDEO_FORMAT_UYVY:
  57. 		size = width * height * 2;
  58. 		ALIGN_SIZE(size, alignment);
  59. 		frame->data[0] = bmalloc(size);
  60. 		frame->linesize[0] = width*2;
  61. 		break;
  62.  
  63. 	case VIDEO_FORMAT_RGBA:
  64. 	case VIDEO_FORMAT_BGRA:
  65. 	case VIDEO_FORMAT_BGRX:
  66. 		size = width * height * 4;
  67. 		ALIGN_SIZE(size, alignment);
  68. 		frame->data[0] = bmalloc(size);
  69. 		frame->linesize[0] = width*4;
  70. 		break;
  71.  
  72. 	case VIDEO_FORMAT_I444:
  73. 		size = width * height;
  74. 		ALIGN_SIZE(size, alignment);
  75. 		frame->data[0] = bmalloc(size * 3);
  76. 		frame->data[1] = (uint8_t*)frame->data[0] + size;
  77. 		frame->data[2] = (uint8_t*)frame->data[1] + size;
  78. 		frame->linesize[0] = width;
  79. 		frame->linesize[1] = width;
  80. 		frame->linesize[2] = width;
  81. 		break;
  82. 	}
  83. }

2.数据拷贝

  1. void video_frame_copy(struct video_frame *dst, const struct video_frame *src,
  2. 		enum video_format format, uint32_t cy)
  3. {
  4. 	switch (format) {
  5. 	case VIDEO_FORMAT_NONE:
  6. 		return;
  7.  
  8. 	case VIDEO_FORMAT_I420:
  9. 		memcpy(dst->data[0], src->data[0], src->linesize[0] * cy);
  10. 		memcpy(dst->data[1], src->data[1], src->linesize[1] * cy / 2);
  11. 		memcpy(dst->data[2], src->data[2], src->linesize[2] * cy / 2);
  12. 		break;
  13.  
  14. 	case VIDEO_FORMAT_NV12:
  15. 		memcpy(dst->data[0], src->data[0], src->linesize[0] * cy);
  16. 		memcpy(dst->data[1], src->data[1], src->linesize[1] * cy / 2);
  17. 		break;
  18.  
  19. 	case VIDEO_FORMAT_Y800:
  20. 	case VIDEO_FORMAT_YVYU:
  21. 	case VIDEO_FORMAT_YUY2:
  22. 	case VIDEO_FORMAT_UYVY:
  23. 	case VIDEO_FORMAT_RGBA:
  24. 	case VIDEO_FORMAT_BGRA:
  25. 	case VIDEO_FORMAT_BGRX:
  26. 		memcpy(dst->data[0], src->data[0], src->linesize[0] * cy);
  27. 		break;
  28.  
  29. 	case VIDEO_FORMAT_I444:
  30. 		memcpy(dst->data[0], src->data[0], src->linesize[0] * cy);
  31. 		memcpy(dst->data[1], src->data[1], src->linesize[1] * cy);
  32. 		memcpy(dst->data[2], src->data[2], src->linesize[2] * cy);
  33. 		break;
  34. 	}
  35. }
  36.  
  37. void video_frame_setblack(struct video_frame *dst, enum video_format format, uint32_t cy)
  38. {
  39. 	switch (format) {
  40. 	case VIDEO_FORMAT_NONE:
  41. 		return;
  42.  
  43. 	case VIDEO_FORMAT_I420:
  44. 		memset(dst->data[0], 0, dst->linesize[0] * cy);
  45.  		memset(dst->data[1], 0x80, dst->linesize[1] * cy / 2);
  46.  		memset(dst->data[2], 0x80, dst->linesize[2] * cy / 2);
  47. 		break;
  48.  
  49. 	case VIDEO_FORMAT_NV12:
  50. 		memset(dst->data[0], 0x10, dst->linesize[0] * cy);
  51. 		memset(dst->data[1], 0x80, dst->linesize[1] * cy / 2);
  52. 		break;
  53.  
  54. 	case VIDEO_FORMAT_Y800:
  55. 	case VIDEO_FORMAT_YVYU:
  56. 	case VIDEO_FORMAT_YUY2:
  57. 	case VIDEO_FORMAT_UYVY:
  58. 	case VIDEO_FORMAT_RGBA:
  59. 	case VIDEO_FORMAT_BGRA:
  60. 	case VIDEO_FORMAT_BGRX:
  61. 		memset(dst->data[0], 0, dst->linesize[0] * cy);
  62. 		break;
  63.  
  64. 	case VIDEO_FORMAT_I444:
  65. 		memset(dst->data[0], 0, dst->linesize[0] * cy*3);
  66. // 		memset(dst->data[1], 0, dst->linesize[0] * cy);
  67. // 		memset(dst->data[2], 0, dst->linesize[0] * cy);
  68. 		break;
  69. 	}
  70. }

3.格式转换

  1. void convert_nv12_to_uyvy(uint8_t* input[], uint32_t in_linesize[],
  2.     uint32_t start_y, uint32_t end_y,
  3.     uint8_t* output, uint32_t out_linesize)
  4. {
  5. 	register uint8_t* _Y;
  6. 	register uint8_t* _U;
  7. 	register uint8_t* _V;
  8. 	register uint8_t* _out;
  9.     uint32_t width = min_uint32(in_linesize[0], out_linesize);
  10. 	uint8_t* _YL = input[0] + (start_y * in_linesize[0]);
  11. 	uint8_t* _UL = input[1] + ((start_y / 2) * in_linesize[1]);
  12. 	
  13. 	uint8_t* _outL = output + (start_y * out_linesize);
  14. 	
  15.  
  16.     for (uint32_t y = start_y; y < end_y; y++) {
  17. 		/*_Y = input[0] + (y * in_linesize[0]);
  18.         _U = input[1] + ((y/2) * in_linesize[1]);
  19.         _V = _U + 1;
  21. 		_out = output + (y * out_linesize);*/
  22. 		_Y = _YL;
  23. 		_U = _UL;
  24. 		_V = _U + 1;
  25.  
  26. 		_out = _outL;
  27.  
  28.         for (uint32_t x = 0; x < width; x+=2) {
  29.             *(_out++) = *(_U++); _U++;
  30.             *(_out++) = *(_Y++);
  31.             *(_out++) = *(_V++); _V++;
  32.             *(_out++) = *(_Y++);
  33.         }
  34.  
  35. 		_YL +=  in_linesize[0];
  36. 		_UL += y&0x1?in_linesize[1]:0;
  37. 		_outL +=  out_linesize;
  38.     }
  39. }
  40.  
  41. void convert_i420_to_uyvy(uint8_t* input[], uint32_t in_linesize[],
  42.     uint32_t start_y, uint32_t end_y,
  43.     uint8_t* output, uint32_t out_linesize)
  44. {
  45.     uint8_t* _Y;
  46.     uint8_t* _U;
  47.     uint8_t* _V;
  48.     uint8_t* _out;
  49.     uint32_t width = min_uint32(in_linesize[0], out_linesize);
  50.     for (uint32_t y = start_y; y < end_y; y++) {
  51.         _Y = input[0] + (y * in_linesize[0]);
  52.         _U = input[1] + ((y/2) * in_linesize[1]);
  53.         _V = input[2] + ((y/2) * in_linesize[2]);
  54.  
  55.         _out = output + (y * out_linesize);
  56.  
  57.         for (uint32_t x = 0; x < width; x += 2) {
  58.             *(_out++) = *(_U++);
  59.             *(_out++) = *(_Y++);
  60.             *(_out++) = *(_V++);
  61.             *(_out++) = *(_Y++);
  62.         }
  63.     }
  64. }
  65.  
  66. void convert_i444_to_uyvy(uint8_t* input[], uint32_t in_linesize[],
  67.     uint32_t start_y, uint32_t end_y,
  68.     uint8_t* output, uint32_t out_linesize)
  69. {
  70.     uint8_t* _Y;
  71.     uint8_t* _U;
  72.     uint8_t* _V;
  73.     uint8_t* _out;
  74.     uint32_t width = min_uint32(in_linesize[0], out_linesize);
  75.     for (uint32_t y = start_y; y < end_y; y++) {
  76.         _Y = input[0] + (y * in_linesize[0]);
  77.         _U = input[1] + (y * in_linesize[1]);
  78.         _V = input[2] + (y * in_linesize[2]);
  79.  
  80.         _out = output + (y * out_linesize);
  81.  
  82.         for (uint32_t x = 0; x < width; x += 2) {
  83.             // Quality loss here. Some chroma samples are ignored.
  84.             *(_out++) = *(_U++); _U++;
  85.             *(_out++) = *(_Y++);
  86.             *(_out++) = *(_V++); _V++;
  87.             *(_out++) = *(_Y++);
  88.         }
  89.     }
  90. }

 

参考资料：

https://github.com/obsproject/obs-studio

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/2023面试高手/article/detail/194967
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号