OLD | NEW |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "media/base/video_frame.h" | 5 #include "media/base/video_frame.h" |
6 | 6 |
7 #include <algorithm> | 7 #include <algorithm> |
8 #include <climits> | 8 #include <climits> |
9 | 9 |
10 #include "base/atomic_sequence_num.h" | 10 #include "base/atomic_sequence_num.h" |
(...skipping 752 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
763 const gfx::Size& natural_size, | 763 const gfx::Size& natural_size, |
764 uint8_t* data, | 764 uint8_t* data, |
765 size_t data_size, | 765 size_t data_size, |
766 base::TimeDelta timestamp, | 766 base::TimeDelta timestamp, |
767 base::SharedMemoryHandle handle, | 767 base::SharedMemoryHandle handle, |
768 size_t data_offset) { | 768 size_t data_offset) { |
769 DCHECK(IsStorageTypeMappable(storage_type)); | 769 DCHECK(IsStorageTypeMappable(storage_type)); |
770 | 770 |
771 // TODO(miu): This function should support any pixel format. | 771 // TODO(miu): This function should support any pixel format. |
772 // http://crbug.com/555909 | 772 // http://crbug.com/555909 |
773 if (format != PIXEL_FORMAT_I420) { | 773 if (format != PIXEL_FORMAT_I420 && format != PIXEL_FORMAT_Y16) { |
774 LOG(DFATAL) << "Only PIXEL_FORMAT_I420 format supported: " | 774 LOG(DFATAL) << "Only PIXEL_FORMAT_I420 and PIXEL_FORMAT_Y16 formats are" |
| 775 "supported: " |
775 << VideoPixelFormatToString(format); | 776 << VideoPixelFormatToString(format); |
776 return nullptr; | 777 return nullptr; |
777 } | 778 } |
778 | 779 |
779 if (!IsValidConfig(format, storage_type, coded_size, visible_rect, | 780 if (!IsValidConfig(format, storage_type, coded_size, visible_rect, |
780 natural_size)) { | 781 natural_size)) { |
781 LOG(DFATAL) << __func__ << " Invalid config." | 782 LOG(DFATAL) << __func__ << " Invalid config." |
782 << ConfigToString(format, storage_type, coded_size, | 783 << ConfigToString(format, storage_type, coded_size, |
783 visible_rect, natural_size); | 784 visible_rect, natural_size); |
784 return nullptr; | 785 return nullptr; |
785 } | 786 } |
786 | 787 |
787 scoped_refptr<VideoFrame> frame; | 788 scoped_refptr<VideoFrame> frame; |
788 if (storage_type == STORAGE_SHMEM) { | 789 if (storage_type == STORAGE_SHMEM) { |
789 frame = new VideoFrame(format, storage_type, coded_size, visible_rect, | 790 frame = new VideoFrame(format, storage_type, coded_size, visible_rect, |
790 natural_size, timestamp, handle, data_offset); | 791 natural_size, timestamp, handle, data_offset); |
791 } else { | 792 } else { |
792 frame = new VideoFrame(format, storage_type, coded_size, visible_rect, | 793 frame = new VideoFrame(format, storage_type, coded_size, visible_rect, |
793 natural_size, timestamp); | 794 natural_size, timestamp); |
794 } | 795 } |
795 frame->strides_[kYPlane] = coded_size.width(); | 796 switch (NumPlanes(format)) { |
796 // TODO(miu): This always rounds widths down, whereas VideoFrame::RowBytes() | 797 case 1: |
797 // always rounds up. This inconsistency must be resolved. Perhaps a | 798 frame->strides_[kYPlane] = RowBytes(kYPlane, format, coded_size.width()); |
798 // CommonAlignment() check should be made in IsValidConfig()? | 799 frame->data_[kYPlane] = data; |
799 // http://crbug.com/555909 | 800 return frame; |
800 frame->strides_[kUPlane] = coded_size.width() / 2; | 801 case 3: |
801 frame->strides_[kVPlane] = coded_size.width() / 2; | 802 DCHECK_EQ(format, PIXEL_FORMAT_I420); |
802 frame->data_[kYPlane] = data; | 803 // TODO(miu): This always rounds widths down, whereas |
803 frame->data_[kUPlane] = data + coded_size.GetArea(); | 804 // VideoFrame::RowBytes() always rounds up. This inconsistency must be |
804 frame->data_[kVPlane] = data + (coded_size.GetArea() * 5 / 4); | 805 // resolved. Perhaps a CommonAlignment() check should be made in |
805 return frame; | 806 // IsValidConfig()? |
| 807 // http://crbug.com/555909 |
| 808 frame->strides_[kYPlane] = RowBytes(kYPlane, format, coded_size.width()); |
| 809 frame->data_[kYPlane] = data; |
| 810 frame->strides_[kVPlane] = coded_size.width() / 2; |
| 811 frame->data_[kVPlane] = data + (coded_size.GetArea() * 5 / 4); |
| 812 frame->strides_[kUPlane] = coded_size.width() / 2; |
| 813 frame->data_[kUPlane] = data + coded_size.GetArea(); |
| 814 return frame; |
| 815 default: |
| 816 LOG(DFATAL) << "Invalid number of planes: " << NumPlanes(format) |
| 817 << " in format: " << VideoPixelFormatToString(format); |
| 818 return nullptr; |
| 819 } |
806 } | 820 } |
807 | 821 |
808 VideoFrame::VideoFrame(VideoPixelFormat format, | 822 VideoFrame::VideoFrame(VideoPixelFormat format, |
809 StorageType storage_type, | 823 StorageType storage_type, |
810 const gfx::Size& coded_size, | 824 const gfx::Size& coded_size, |
811 const gfx::Rect& visible_rect, | 825 const gfx::Rect& visible_rect, |
812 const gfx::Size& natural_size, | 826 const gfx::Size& natural_size, |
813 base::TimeDelta timestamp) | 827 base::TimeDelta timestamp) |
814 : format_(format), | 828 : format_(format), |
815 storage_type_(storage_type), | 829 storage_type_(storage_type), |
(...skipping 149 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
965 case kAPlane: | 979 case kAPlane: |
966 return gfx::Size(1, 1); | 980 return gfx::Size(1, 1); |
967 | 981 |
968 case kUPlane: // and kUVPlane: | 982 case kUPlane: // and kUVPlane: |
969 case kVPlane: | 983 case kVPlane: |
970 switch (format) { | 984 switch (format) { |
971 case PIXEL_FORMAT_YV24: | 985 case PIXEL_FORMAT_YV24: |
972 case PIXEL_FORMAT_YUV444P9: | 986 case PIXEL_FORMAT_YUV444P9: |
973 case PIXEL_FORMAT_YUV444P10: | 987 case PIXEL_FORMAT_YUV444P10: |
974 case PIXEL_FORMAT_YUV444P12: | 988 case PIXEL_FORMAT_YUV444P12: |
| 989 case PIXEL_FORMAT_Y16: |
975 return gfx::Size(1, 1); | 990 return gfx::Size(1, 1); |
976 | 991 |
977 case PIXEL_FORMAT_YV16: | 992 case PIXEL_FORMAT_YV16: |
978 case PIXEL_FORMAT_YUV422P9: | 993 case PIXEL_FORMAT_YUV422P9: |
979 case PIXEL_FORMAT_YUV422P10: | 994 case PIXEL_FORMAT_YUV422P10: |
980 case PIXEL_FORMAT_YUV422P12: | 995 case PIXEL_FORMAT_YUV422P12: |
981 return gfx::Size(2, 1); | 996 return gfx::Size(2, 1); |
982 | 997 |
983 case PIXEL_FORMAT_YV12: | 998 case PIXEL_FORMAT_YV12: |
984 case PIXEL_FORMAT_I420: | 999 case PIXEL_FORMAT_I420: |
985 case PIXEL_FORMAT_YV12A: | 1000 case PIXEL_FORMAT_YV12A: |
986 case PIXEL_FORMAT_NV12: | 1001 case PIXEL_FORMAT_NV12: |
987 case PIXEL_FORMAT_NV21: | 1002 case PIXEL_FORMAT_NV21: |
988 case PIXEL_FORMAT_MT21: | 1003 case PIXEL_FORMAT_MT21: |
989 case PIXEL_FORMAT_YUV420P9: | 1004 case PIXEL_FORMAT_YUV420P9: |
990 case PIXEL_FORMAT_YUV420P10: | 1005 case PIXEL_FORMAT_YUV420P10: |
991 case PIXEL_FORMAT_YUV420P12: | 1006 case PIXEL_FORMAT_YUV420P12: |
992 return gfx::Size(2, 2); | 1007 return gfx::Size(2, 2); |
993 | 1008 |
994 case PIXEL_FORMAT_UNKNOWN: | 1009 case PIXEL_FORMAT_UNKNOWN: |
995 case PIXEL_FORMAT_UYVY: | 1010 case PIXEL_FORMAT_UYVY: |
996 case PIXEL_FORMAT_YUY2: | 1011 case PIXEL_FORMAT_YUY2: |
997 case PIXEL_FORMAT_ARGB: | 1012 case PIXEL_FORMAT_ARGB: |
998 case PIXEL_FORMAT_XRGB: | 1013 case PIXEL_FORMAT_XRGB: |
999 case PIXEL_FORMAT_RGB24: | 1014 case PIXEL_FORMAT_RGB24: |
1000 case PIXEL_FORMAT_RGB32: | 1015 case PIXEL_FORMAT_RGB32: |
1001 case PIXEL_FORMAT_MJPEG: | 1016 case PIXEL_FORMAT_MJPEG: |
1002 case PIXEL_FORMAT_Y8: | 1017 case PIXEL_FORMAT_Y8: |
1003 case PIXEL_FORMAT_Y16: | |
1004 break; | 1018 break; |
1005 } | 1019 } |
1006 } | 1020 } |
1007 NOTREACHED(); | 1021 NOTREACHED(); |
1008 return gfx::Size(); | 1022 return gfx::Size(); |
1009 } | 1023 } |
1010 | 1024 |
1011 // static | 1025 // static |
1012 int VideoFrame::BytesPerElement(VideoPixelFormat format, size_t plane) { | 1026 int VideoFrame::BytesPerElement(VideoPixelFormat format, size_t plane) { |
1013 DCHECK(IsValidPlane(plane, format)); | 1027 DCHECK(IsValidPlane(plane, format)); |
(...skipping 81 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1095 if (zero_initialize_memory) | 1109 if (zero_initialize_memory) |
1096 memset(data, 0, data_size); | 1110 memset(data, 0, data_size); |
1097 | 1111 |
1098 for (size_t plane = 0; plane < NumPlanes(format_); ++plane) | 1112 for (size_t plane = 0; plane < NumPlanes(format_); ++plane) |
1099 data_[plane] = data + offset[plane]; | 1113 data_[plane] = data + offset[plane]; |
1100 | 1114 |
1101 AddDestructionObserver(base::Bind(&base::AlignedFree, data)); | 1115 AddDestructionObserver(base::Bind(&base::AlignedFree, data)); |
1102 } | 1116 } |
1103 | 1117 |
1104 } // namespace media | 1118 } // namespace media |
OLD | NEW |