OLD | NEW |
| (Empty) |
1 /* | |
2 * Copyright (c) 2015 The WebRTC project authors. All Rights Reserved. | |
3 * | |
4 * Use of this source code is governed by a BSD-style license | |
5 * that can be found in the LICENSE file in the root of the source | |
6 * tree. An additional intellectual property rights grant can be found | |
7 * in the file PATENTS. All contributing project authors may | |
8 * be found in the AUTHORS file in the root of the source tree. | |
9 * | |
10 */ | |
11 | |
12 #ifndef WEBRTC_MODULES_VIDEO_CODING_CODECS_H264_H264_VIDEO_TOOLBOX_NALU_H_ | |
13 #define WEBRTC_MODULES_VIDEO_CODING_CODECS_H264_H264_VIDEO_TOOLBOX_NALU_H_ | |
14 | |
15 #include "webrtc/modules/video_coding/codecs/h264/include/h264.h" | |
16 | |
17 #if defined(WEBRTC_VIDEO_TOOLBOX_SUPPORTED) | |
18 | |
19 #include <CoreMedia/CoreMedia.h> | |
20 | |
21 #include "webrtc/base/buffer.h" | |
22 #include "webrtc/modules/include/module_common_types.h" | |
23 | |
24 namespace webrtc { | |
25 | |
26 // Converts a sample buffer emitted from the VideoToolbox encoder into a buffer | |
27 // suitable for RTP. The sample buffer is in avcc format whereas the rtp buffer | |
28 // needs to be in Annex B format. Data is written directly to |annexb_buffer| | |
29 // and a new RTPFragmentationHeader is returned in |out_header|. | |
30 bool H264CMSampleBufferToAnnexBBuffer( | |
31 CMSampleBufferRef avcc_sample_buffer, | |
32 bool is_keyframe, | |
33 rtc::Buffer* annexb_buffer, | |
34 webrtc::RTPFragmentationHeader** out_header); | |
35 | |
36 // Converts a buffer received from RTP into a sample buffer suitable for the | |
37 // VideoToolbox decoder. The RTP buffer is in annex b format whereas the sample | |
38 // buffer is in avcc format. | |
39 // If |is_keyframe| is true then |video_format| is ignored since the format will | |
40 // be read from the buffer. Otherwise |video_format| must be provided. | |
41 // Caller is responsible for releasing the created sample buffer. | |
42 bool H264AnnexBBufferToCMSampleBuffer(const uint8_t* annexb_buffer, | |
43 size_t annexb_buffer_size, | |
44 CMVideoFormatDescriptionRef video_format, | |
45 CMSampleBufferRef* out_sample_buffer); | |
46 | |
47 // Returns true if the type of the first NALU in the supplied Annex B buffer is | |
48 // the SPS type. | |
49 bool H264AnnexBBufferHasVideoFormatDescription(const uint8_t* annexb_buffer, | |
50 size_t annexb_buffer_size); | |
51 | |
52 // Returns a video format description created from the sps/pps information in | |
53 // the Annex B buffer. If there is no such information, nullptr is returned. | |
54 // The caller is responsible for releasing the description. | |
55 CMVideoFormatDescriptionRef CreateVideoFormatDescription( | |
56 const uint8_t* annexb_buffer, | |
57 size_t annexb_buffer_size); | |
58 | |
59 // Helper class for reading NALUs from an RTP Annex B buffer. | |
60 class AnnexBBufferReader final { | |
61 public: | |
62 AnnexBBufferReader(const uint8_t* annexb_buffer, size_t length); | |
63 ~AnnexBBufferReader() {} | |
64 AnnexBBufferReader(const AnnexBBufferReader& other) = delete; | |
65 void operator=(const AnnexBBufferReader& other) = delete; | |
66 | |
67 // Returns a pointer to the beginning of the next NALU slice without the | |
68 // header bytes and its length. Returns false if no more slices remain. | |
69 bool ReadNalu(const uint8_t** out_nalu, size_t* out_length); | |
70 | |
71 // Returns the number of unread NALU bytes, including the size of the header. | |
72 // If the buffer has no remaining NALUs this will return zero. | |
73 size_t BytesRemaining() const; | |
74 | |
75 private: | |
76 // Returns the the next offset that contains NALU data. | |
77 size_t FindNextNaluHeader(const uint8_t* start, | |
78 size_t length, | |
79 size_t offset) const; | |
80 | |
81 const uint8_t* const start_; | |
82 size_t offset_; | |
83 size_t next_offset_; | |
84 const size_t length_; | |
85 }; | |
86 | |
87 // Helper class for writing NALUs using avcc format into a buffer. | |
88 class AvccBufferWriter final { | |
89 public: | |
90 AvccBufferWriter(uint8_t* const avcc_buffer, size_t length); | |
91 ~AvccBufferWriter() {} | |
92 AvccBufferWriter(const AvccBufferWriter& other) = delete; | |
93 void operator=(const AvccBufferWriter& other) = delete; | |
94 | |
95 // Writes the data slice into the buffer. Returns false if there isn't | |
96 // enough space left. | |
97 bool WriteNalu(const uint8_t* data, size_t data_size); | |
98 | |
99 // Returns the unused bytes in the buffer. | |
100 size_t BytesRemaining() const; | |
101 | |
102 private: | |
103 uint8_t* const start_; | |
104 size_t offset_; | |
105 const size_t length_; | |
106 }; | |
107 | |
108 } // namespace webrtc | |
109 | |
110 #endif // defined(WEBRTC_VIDEO_TOOLBOX_SUPPORTED) | |
111 #endif // WEBRTC_MODULES_VIDEO_CODING_CODECS_H264_H264_VIDEO_TOOLBOX_NALU_H_ | |
OLD | NEW |