FFmpeg: libavcodec/cbs_sei_syntax_template.c Source File

FFmpeg

[フレーム]

libavcodec

cbs_sei_syntax_template.c

Go to the documentation of this file.

1 /*

2 * This file is part of FFmpeg.

3 *

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

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

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

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

8 *

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

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

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

12 * Lesser General Public License for more details.

13 *

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

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

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

17 */

19 static int FUNC(filler_payload)

20 (CodedBitstreamContext *ctx, RWContext *rw,

21 SEIRawFillerPayload *current, SEIMessageState *state)

22 {

23 int err, i;

25 HEADER("Filler Payload");

27 #ifdef READ

28 current->payload_size = state->payload_size;

29 #endif

31 for (i = 0; i < current->payload_size; i++)

32 fixed(8, ff_byte, 0xff);

34 return 0;

35 }

37 static int FUNC(user_data_registered)

38 (CodedBitstreamContext *ctx, RWContext *rw,

39 SEIRawUserDataRegistered *current, SEIMessageState *state)

40 {

41 int err, i, j;

43 HEADER("User Data Registered ITU-T T.35");

45 u(8, itu_t_t35_country_code, 0x00, 0xff);

46 if (current->itu_t_t35_country_code != 0xff)

47 i = 1;

48 else {

49 u(8, itu_t_t35_country_code_extension_byte, 0x00, 0xff);

50 i = 2;

51 }

53 #ifdef READ

54 if (state->payload_size < i) {

55 av_log(ctx->log_ctx, AV_LOG_ERROR,

56 "Invalid SEI user data registered payload.\n");

57 return AVERROR_INVALIDDATA;

58 }

59 current->data_length = state->payload_size - i;

60 #endif

62 allocate(current->data, current->data_length);

63 for (j = 0; j < current->data_length; j++)

64 xu(8, itu_t_t35_payload_byte[], current->data[j], 0x00, 0xff, 1, i + j);

66 return 0;

67 }

69 static int FUNC(user_data_unregistered)

70 (CodedBitstreamContext *ctx, RWContext *rw,

71 SEIRawUserDataUnregistered *current, SEIMessageState *state)

72 {

73 int err, i;

75 HEADER("User Data Unregistered");

77 #ifdef READ

78 if (state->payload_size < 16) {

79 av_log(ctx->log_ctx, AV_LOG_ERROR,

80 "Invalid SEI user data unregistered payload.\n");

81 return AVERROR_INVALIDDATA;

82 }

83 current->data_length = state->payload_size - 16;

84 #endif

86 for (i = 0; i < 16; i++)

87 us(8, uuid_iso_iec_11578[i], 0x00, 0xff, 1, i);

89 allocate(current->data, current->data_length);

91 for (i = 0; i < current->data_length; i++)

92 xu(8, user_data_payload_byte[i], current->data[i], 0x00, 0xff, 1, i);

94 return 0;

95 }

97 static int FUNC(mastering_display_colour_volume)

98 (CodedBitstreamContext *ctx, RWContext *rw,

99 SEIRawMasteringDisplayColourVolume *current, SEIMessageState *state)

100 {

101 int err, c;

102

103 HEADER("Mastering Display Colour Volume");

104

105 for (c = 0; c < 3; c++) {

106 ubs(16, display_primaries_x[c], 1, c);

107 ubs(16, display_primaries_y[c], 1, c);

108 }

109

110 ub(16, white_point_x);

111 ub(16, white_point_y);

112

113 ub(32, max_display_mastering_luminance);

114 ub(32, min_display_mastering_luminance);

115

116 return 0;

117 }

118

119 static int FUNC(content_light_level_info)

120 (CodedBitstreamContext *ctx, RWContext *rw,

121 SEIRawContentLightLevelInfo *current, SEIMessageState *state)

122 {

123 int err;

124

125 HEADER("Content Light Level Information");

126

127 ub(16, max_content_light_level);

128 ub(16, max_pic_average_light_level);

129

130 return 0;

131 }

132

133 static int FUNC(alternative_transfer_characteristics)

134 (CodedBitstreamContext *ctx, RWContext *rw,

135 SEIRawAlternativeTransferCharacteristics *current,

136 SEIMessageState *state)

137 {

138 int err;

139

140 HEADER("Alternative Transfer Characteristics");

141

142 ub(8, preferred_transfer_characteristics);

143

144 return 0;

145 }

146

147 static int FUNC(message)(CodedBitstreamContext *ctx, RWContext *rw,

148 SEIRawMessage *current)

149 {

150 const SEIMessageTypeDescriptor *desc;

151 int err, i;

152

153 desc = ff_cbs_sei_find_type(ctx, current->payload_type);

154 if (desc) {

155 SEIMessageState state = {

156 .payload_type = current->payload_type,

157 .payload_size = current->payload_size,

158 .extension_present = current->extension_bit_length > 0,

159 };

160 int start_position, current_position, bits_written;

161

162 #ifdef READ

163 CHECK(ff_cbs_sei_alloc_message_payload(current, desc));

164 #endif

165

166 start_position = bit_position(rw);

167

168 CHECK(desc->READWRITE(ctx, rw, current->payload, &state));

169

170 current_position = bit_position(rw);

171 bits_written = current_position - start_position;

172

173 if (byte_alignment(rw) || state.extension_present ||

174 bits_written < 8 * current->payload_size) {

175 size_t bits_left;

176

177 #ifdef READ

178 GetBitContext tmp = *rw;

179 int trailing_bits, trailing_zero_bits;

180

181 bits_left = 8 * current->payload_size - bits_written;

182 if (bits_left > 8)

183 skip_bits_long(&tmp, bits_left - 8);

184 trailing_bits = get_bits(&tmp, FFMIN(bits_left, 8));

185 if (trailing_bits == 0) {

186 // The trailing bits must contain a bit_equal_to_one, so

187 // they can't all be zero.

188 return AVERROR_INVALIDDATA;

189 }

190 trailing_zero_bits = ff_ctz(trailing_bits);

191 current->extension_bit_length =

192 bits_left - 1 - trailing_zero_bits;

193 #endif

194

195 if (current->extension_bit_length > 0) {

196 allocate(current->extension_data,

197 (current->extension_bit_length + 7) / 8);

198

199 bits_left = current->extension_bit_length;

200 for (i = 0; bits_left > 0; i++) {

201 int length = FFMIN(bits_left, 8);

202 xu(length, reserved_payload_extension_data,

203 current->extension_data[i],

204 0, MAX_UINT_BITS(length), 0);

205 bits_left -= length;

206 }

207 }

208

209 fixed(1, bit_equal_to_one, 1);

210 while (byte_alignment(rw))

211 fixed(1, bit_equal_to_zero, 0);

212 }

213

214 #ifdef WRITE

215 current->payload_size = (put_bits_count(rw) - start_position) / 8;

216 #endif

217 } else {

218 uint8_t *data;

219

220 allocate(current->payload, current->payload_size);

221 data = current->payload;

222

223 for (i = 0; i < current->payload_size; i++)

224 xu(8, payload_byte[i], data[i], 0, 255, 1, i);

225 }

226

227 return 0;

228 }

229

230 static int FUNC(message_list)(CodedBitstreamContext *ctx, RWContext *rw,

231 SEIRawMessageList *current, int prefix)

232 {

233 SEIRawMessage *message;

234 int err, k;

235

236 #ifdef READ

237 for (k = 0;; k++) {

238 uint32_t payload_type = 0;

239 uint32_t payload_size = 0;

240 uint32_t tmp;

241 GetBitContext payload_gbc;

242

243 while (show_bits(rw, 8) == 0xff) {

244 fixed(8, ff_byte, 0xff);

245 payload_type += 255;

246 }

247 xu(8, last_payload_type_byte, tmp, 0, 254, 0);

248 payload_type += tmp;

249

250 while (show_bits(rw, 8) == 0xff) {

251 fixed(8, ff_byte, 0xff);

252 payload_size += 255;

253 }

254 xu(8, last_payload_size_byte, tmp, 0, 254, 0);

255 payload_size += tmp;

256

257 // There must be space remaining for both the payload and

258 // the trailing bits on the SEI NAL unit.

259 if (payload_size + 1 > get_bits_left(rw) / 8) {

260 av_log(ctx->log_ctx, AV_LOG_ERROR,

261 "Invalid SEI message: payload_size too large "

262 "(%"PRIu32" bytes).\n", payload_size);

263 return AVERROR_INVALIDDATA;

264 }

265 CHECK(init_get_bits(&payload_gbc, rw->buffer,

266 get_bits_count(rw) + 8 * payload_size));

267 skip_bits_long(&payload_gbc, get_bits_count(rw));

268

269 CHECK(ff_cbs_sei_list_add(current));

270 message = &current->messages[k];

271

272 message->payload_type = payload_type;

273 message->payload_size = payload_size;

274

275 CHECK(FUNC(message)(ctx, &payload_gbc, message));

276

277 skip_bits_long(rw, 8 * payload_size);

278

279 if (!cbs_h2645_read_more_rbsp_data(rw))

280 break;

281 }

282 #else

283 for (k = 0; k < current->nb_messages; k++) {

284 PutBitContext start_state;

285 uint32_t tmp;

286 int trace, i;

287

288 message = &current->messages[k];

289

290 // We write the payload twice in order to find the size. Trace

291 // output is switched off for the first write.

292 trace = ctx->trace_enable;

293 ctx->trace_enable = 0;

294

295 start_state = *rw;

296 for (i = 0; i < 2; i++) {

297 *rw = start_state;

298

299 tmp = message->payload_type;

300 while (tmp >= 255) {

301 fixed(8, ff_byte, 0xff);

302 tmp -= 255;

303 }

304 xu(8, last_payload_type_byte, tmp, 0, 254, 0);

305

306 tmp = message->payload_size;

307 while (tmp >= 255) {

308 fixed(8, ff_byte, 0xff);

309 tmp -= 255;

310 }

311 xu(8, last_payload_size_byte, tmp, 0, 254, 0);

312

313 err = FUNC(message)(ctx, rw, message);

314 ctx->trace_enable = trace;

315 if (err < 0)

316 return err;

317 }

318 }

319 #endif

320

321 return 0;

322 }

bit_position

#define bit_position(rw)

Definition: cbs_h2645.c:429

skip_bits_long

static void skip_bits_long(GetBitContext *s, int n)

Skips the specified number of bits.

Definition: get_bits.h:292

get_bits_left

static int get_bits_left(GetBitContext *gb)

Definition: get_bits.h:850

filler_payload

static int FUNC() filler_payload(CodedBitstreamContext *ctx, RWContext *rw, SEIRawFillerPayload *current, SEIMessageState *state)

Definition: cbs_sei_syntax_template.c:20

byte_alignment

#define byte_alignment(rw)

Definition: cbs_av1.c:719

SEIRawUserDataRegistered

Definition: cbs_sei.h:35

ff_ctz

#define ff_ctz

Definition: intmath.h:106

message

Definition: api-threadmessage-test.c:46

#define u(width, name, range_min, range_max)

Definition: cbs_h2645.c:264

SEIRawMessage

Definition: cbs_sei.h:68

get_bits_count

static int get_bits_count(const GetBitContext *s)

Definition: get_bits.h:220

HEADER

#define HEADER(name)

Definition: cbs_av1.c:533

tmp

static uint8_t tmp[11]

Definition: aes_ctr.c:26

CodedBitstreamContext

Context structure for coded bitstream operations.

Definition: cbs.h:173

data

const char data[16]

Definition: mxf.c:143

SEIRawAlternativeTransferCharacteristics

Definition: cbs_sei.h:64

allocate

#define allocate(name, size)

Definition: cbs_h2645.c:432

init_get_bits

static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)

Initialize GetBitContext.

Definition: get_bits.h:660

SEIRawContentLightLevelInfo

Definition: cbs_sei.h:59

get_bits

static unsigned int get_bits(GetBitContext *s, int n)

Read 1-25 bits.

Definition: get_bits.h:380

CHECK

CHECK(-1) CHECK(-2) }} }} CHECK(1) CHECK(2) }} }} } if(diff0+diff1 > 0) temp -

GetBitContext

Definition: get_bits.h:62

#define ub(width, name)

Definition: cbs_h2645.c:266

SEIRawUserDataUnregistered

Definition: cbs_sei.h:43

#define us(width, name, range_min, range_max, subs,...)

Definition: cbs_h2645.c:278

alternative_transfer_characteristics

static int FUNC() alternative_transfer_characteristics(CodedBitstreamContext *ctx, RWContext *rw, SEIRawAlternativeTransferCharacteristics *current, SEIMessageState *state)

Definition: cbs_sei_syntax_template.c:134

mastering_display_colour_volume

static int FUNC() mastering_display_colour_volume(CodedBitstreamContext *ctx, RWContext *rw, SEIRawMasteringDisplayColourVolume *current, SEIMessageState *state)

Definition: cbs_sei_syntax_template.c:98

message_list

static int FUNC() message_list(CodedBitstreamContext *ctx, RWContext *rw, SEIRawMessageList *current, int prefix)

Definition: cbs_sei_syntax_template.c:230

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:180

SEIRawFillerPayload

Definition: cbs_sei.h:31

SEIRawMessageList

Definition: cbs_sei.h:78

ctx

AVFormatContext * ctx

Definition: movenc.c:48

ff_cbs_sei_alloc_message_payload

int ff_cbs_sei_alloc_message_payload(SEIRawMessage *message, const SEIMessageTypeDescriptor *desc)

Allocate a new payload for the given SEI message.

Definition: cbs_sei.c:39

MAX_UINT_BITS

#define MAX_UINT_BITS(length)

Definition: cbs_internal.h:174

PutBitContext

Definition: put_bits.h:49

GetBitContext::buffer

const uint8_t * buffer

Definition: get_bits.h:63

SEIMessageTypeDescriptor

Definition: cbs_sei.h:113

SEIRawMasteringDisplayColourVolume

Definition: cbs_sei.h:50

user_data_unregistered

static int FUNC() user_data_unregistered(CodedBitstreamContext *ctx, RWContext *rw, SEIRawUserDataUnregistered *current, SEIMessageState *state)

Definition: cbs_sei_syntax_template.c:70

Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c

Definition: undefined.txt:32

state

static struct @320 state

ff_cbs_sei_find_type

const SEIMessageTypeDescriptor * ff_cbs_sei_find_type(CodedBitstreamContext *ctx, int payload_type)

Find the type descriptor for the given payload type.

Definition: cbs_h2645.c:1652

ubs

#define ubs(width, name, subs,...)

Definition: cbs_h2645.c:280

#define i(width, name, range_min, range_max)

Definition: cbs_h2645.c:271