FFmpeg: libavcodec/av1_parse.h Source File

FFmpeg

[フレーム]

libavcodec

av1_parse.h

Go to the documentation of this file.

1 /*

2 * AV1 common parsing code

3 *

4 * This file is part of FFmpeg.

5 *

6 * FFmpeg is free software; you can redistribute it and/or

7 * modify it under the terms of the GNU Lesser General Public

8 * License as published by the Free Software Foundation; either

9 * version 2.1 of the License, or (at your option) any later version.

10 *

11 * FFmpeg is distributed in the hope that it will be useful,

12 * but WITHOUT ANY WARRANTY; without even the implied warranty of

13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

14 * Lesser General Public License for more details.

15 *

16 * You should have received a copy of the GNU Lesser General Public

17 * License along with FFmpeg; if not, write to the Free Software

18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

19 */

21 #ifndef AVCODEC_AV1_PARSE_H

22 #define AVCODEC_AV1_PARSE_H

24 #include <limits.h>

25 #include <stdint.h>

27 #include "libavutil/error.h"

28 #include "libavutil/intmath.h"

29 #include "libavutil/macros.h"

31 #include "av1.h"

32 #include "get_bits.h"

33 #include "leb.h"

35 // OBU header fields + max leb128 length

36 #define MAX_OBU_HEADER_SIZE (2 + 8)

38 typedef struct AV1OBU {

39 /** Size of payload */

40 int size;

41 const uint8_t *data;

43 /**

44 * Size, in bits, of just the data, excluding the trailing_one_bit and

45 * any trailing padding.

46 */

47 int size_bits;

49 /** Size of entire OBU, including header */

50 int raw_size;

51 const uint8_t *raw_data;

53 int type;

55 int temporal_id;

56 int spatial_id;

57 } AV1OBU;

59 /** An input packet split into OBUs */

60 typedef struct AV1Packet {

61 AV1OBU *obus;

62 int nb_obus;

63 int obus_allocated;

64 unsigned obus_allocated_size;

65 } AV1Packet;

67 /**

68 * Extract an OBU from a raw bitstream.

69 *

70 * @note This function does not copy or store any bitstream data. All

71 * the pointers in the AV1OBU structure will be valid as long

72 * as the input buffer also is.

73 */

74 int ff_av1_extract_obu(AV1OBU *obu, const uint8_t *buf, int length,

75 void *logctx);

77 /**

78 * Split an input packet into OBUs.

79 *

80 * @note This function does not copy or store any bitstream data. All

81 * the pointers in the AV1Packet structure will be valid as

82 * long as the input buffer also is.

83 */

84 int ff_av1_packet_split(AV1Packet *pkt, const uint8_t *buf, int length,

85 void *logctx);

87 /**

88 * Free all the allocated memory in the packet.

89 */

90 void ff_av1_packet_uninit(AV1Packet *pkt);

92 static inline int parse_obu_header(const uint8_t *buf, int buf_size,

93 int64_t *obu_size, int *start_pos, int *type,

94 int *temporal_id, int *spatial_id)

95 {

96 GetBitContext gb;

97 int ret, extension_flag, has_size_flag;

98 int64_t size;

100 ret = init_get_bits8(&gb, buf, FFMIN(buf_size, MAX_OBU_HEADER_SIZE));

101 if (ret < 0)

102 return ret;

103

104 if (get_bits1(&gb) != 0) // obu_forbidden_bit

105 return AVERROR_INVALIDDATA;

106

107 *type = get_bits(&gb, 4);

108 extension_flag = get_bits1(&gb);

109 has_size_flag = get_bits1(&gb);

110 skip_bits1(&gb); // obu_reserved_1bit

111

112 if (extension_flag) {

113 *temporal_id = get_bits(&gb, 3);

114 *spatial_id = get_bits(&gb, 2);

115 skip_bits(&gb, 3); // extension_header_reserved_3bits

116 } else {

117 *temporal_id = *spatial_id = 0;

118 }

119

120 *obu_size = has_size_flag ? get_leb128(&gb)

121 : buf_size - 1 - extension_flag;

122

123 if (get_bits_left(&gb) < 0)

124 return AVERROR_INVALIDDATA;

125

126 *start_pos = get_bits_count(&gb) / 8;

127

128 size = *obu_size + *start_pos;

129

130 if (size > buf_size)

131 return AVERROR_INVALIDDATA;

132

133 return size;

134 }

135

136 static inline int get_obu_bit_length(const uint8_t *buf, int size, int type)

137 {

138 int v;

139

140 /* There are no trailing bits on these */

141 if (type == AV1_OBU_TILE_GROUP ||

142 type == AV1_OBU_TILE_LIST ||

143 type == AV1_OBU_FRAME) {

144 if (size > INT_MAX / 8)

145 return AVERROR(ERANGE);

146 else

147 return size * 8;

148 }

149

150 while (size > 0 && buf[size - 1] == 0)

151 size--;

152

153 if (!size)

154 return 0;

155

156 v = buf[size - 1];

157

158 if (size > INT_MAX / 8)

159 return AVERROR(ERANGE);

160 size *= 8;

161

162 /* Remove the trailing_one_bit and following trailing zeros */

163 if (v)

164 size -= ff_ctz(v) + 1;

165

166 return size;

167 }

168

169 AVRational ff_av1_framerate(int64_t ticks_per_frame, int64_t units_per_tick,

170 int64_t time_scale);

171

172 #endif /* AVCODEC_AV1_PARSE_H */

get_bits_left

static int get_bits_left(GetBitContext *gb)

Definition: get_bits.h:694

AVERROR

Filter the word "frame" indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions

AV1OBU::size

int size

Size of payload.

Definition: av1_parse.h:40

ff_ctz

#define ff_ctz

Definition: intmath.h:105

int64_t

long long int64_t

Definition: coverity.c:34

get_bits_count

static int get_bits_count(const GetBitContext *s)