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 SEI_FUNC(filler_payload, (CodedBitstreamContext *ctx, RWContext *rw,

20 SEIRawFillerPayload *current,

21 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 SEI_FUNC(user_data_registered, (CodedBitstreamContext *ctx, RWContext *rw,

38 SEIRawUserDataRegistered *current,

39 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 SEI_FUNC(user_data_unregistered, (CodedBitstreamContext *ctx, RWContext *rw,

70 SEIRawUserDataUnregistered *current,

71 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 SEI_FUNC(mastering_display_colour_volume,

98 (CodedBitstreamContext *ctx, RWContext *rw,

99 SEIRawMasteringDisplayColourVolume *current,

100 SEIMessageState *state))

101 {

102 int err, c;

103

104 HEADER("Mastering Display Colour Volume");

105

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

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

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

109 }

110

111 ub(16, white_point_x);

112 ub(16, white_point_y);

113

114 ub(32, max_display_mastering_luminance);

115 ub(32, min_display_mastering_luminance);

116

117 return 0;

118 }

119

120 SEI_FUNC(content_light_level_info, (CodedBitstreamContext *ctx, RWContext *rw,

121 SEIRawContentLightLevelInfo *current,

122 SEIMessageState *state))

123 {

124 int err;

125

126 HEADER("Content Light Level Information");

127

128 ub(16, max_content_light_level);

129 ub(16, max_pic_average_light_level);

130

131 return 0;

132 }

133

134 SEI_FUNC(alternative_transfer_characteristics,

135 (CodedBitstreamContext *ctx, RWContext *rw,

136 SEIRawAlternativeTransferCharacteristics *current,

137 SEIMessageState *state))

138 {

139 int err;

140

141 HEADER("Alternative Transfer Characteristics");

142

143 ub(8, preferred_transfer_characteristics);

144

145 return 0;

146 }

147

148 SEI_FUNC(ambient_viewing_environment,

149 (CodedBitstreamContext *ctx, RWContext *rw,

150 SEIRawAmbientViewingEnvironment *current,

151 SEIMessageState *state))

152 {

153 static const uint16_t max_ambient_light_value = 50000;

154 int err;

155

156 HEADER("Ambient Viewing Environment");

157

158 u(32, ambient_illuminance, 1, MAX_UINT_BITS(32));

159 u(16, ambient_light_x, 0, max_ambient_light_value);

160 u(16, ambient_light_y, 0, max_ambient_light_value);

161

162 return 0;

163 }

164

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

166 SEIRawMessage *current)

167 {

168 const SEIMessageTypeDescriptor *desc;

169 int err, i;

170

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

172 if (desc) {

173 SEIMessageState state = {

174 .payload_type = current->payload_type,

175 .payload_size = current->payload_size,

176 .extension_present = current->extension_bit_length > 0,

177 };

178 int start_position, current_position, bits_written;

179

180 #ifdef READ

181 CHECK(ff_cbs_sei_alloc_message_payload(current, desc));

182 #endif

183

184 start_position = bit_position(rw);

185

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

187

188 current_position = bit_position(rw);

189 bits_written = current_position - start_position;

190

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

192 bits_written < 8 * current->payload_size) {

193 size_t bits_left;

194

195 #ifdef READ

196 GetBitContext tmp = *rw;

197 int trailing_bits, trailing_zero_bits;

198

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

200 if (bits_left > 8)

201 skip_bits_long(&tmp, bits_left - 8);

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

203 if (trailing_bits == 0) {

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

205 // they can't all be zero.

206 return AVERROR_INVALIDDATA;

207 }

208 trailing_zero_bits = ff_ctz(trailing_bits);

209 current->extension_bit_length =

210 bits_left - 1 - trailing_zero_bits;

211 #endif

212

213 if (current->extension_bit_length > 0) {

214 allocate(current->extension_data,

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

216

217 bits_left = current->extension_bit_length;

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

219 int length = FFMIN(bits_left, 8);

220 xu(length, reserved_payload_extension_data,

221 current->extension_data[i],

222 0, MAX_UINT_BITS(length), 0);

223 bits_left -= length;

224 }

225 }

226

227 fixed(1, bit_equal_to_one, 1);

228 while (byte_alignment(rw))

229 fixed(1, bit_equal_to_zero, 0);

230 }

231

232 #ifdef WRITE

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

234 #endif

235 } else {

236 uint8_t *data;

237

238 #ifdef READ

239 allocate(current->payload_ref, current->payload_size);

240 current->payload = current->payload_ref;

241 #else

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

243 #endif

244 data = current->payload;

245

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

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

248 }

249

250 return 0;

251 }

252

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

254 SEIRawMessageList *current, int prefix)

255 {

256 SEIRawMessage *message;

257 int err, k;

258

259 #ifdef READ

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

261 uint32_t payload_type = 0;

262 uint32_t payload_size = 0;

263 uint32_t tmp;

264 GetBitContext payload_gbc;

265

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

267 fixed(8, ff_byte, 0xff);

268 payload_type += 255;

269 }

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

271 payload_type += tmp;

272

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

274 fixed(8, ff_byte, 0xff);

275 payload_size += 255;

276 }

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

278 payload_size += tmp;

279

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

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

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

283 av_log(ctx->log_ctx, AV_LOG_ERROR,

284 "Invalid SEI message: payload_size too large "

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

286 return AVERROR_INVALIDDATA;

287 }

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

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

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

291

292 CHECK(ff_cbs_sei_list_add(current));

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

294

295 message->payload_type = payload_type;

296 message->payload_size = payload_size;

297

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

299

300 skip_bits_long(rw, 8 * payload_size);

301

302 if (!cbs_h2645_read_more_rbsp_data(rw))

303 break;

304 }

305 #else

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

307 PutBitContext start_state;

308 uint32_t tmp;

309 int trace, i;

310

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

312

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

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

315 trace = ctx->trace_enable;

316 ctx->trace_enable = 0;

317

318 start_state = *rw;

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

320 *rw = start_state;

321

322 tmp = message->payload_type;

323 while (tmp >= 255) {

324 fixed(8, ff_byte, 0xff);

325 tmp -= 255;

326 }

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

328

329 tmp = message->payload_size;

330 while (tmp >= 255) {

331 fixed(8, ff_byte, 0xff);

332 tmp -= 255;

333 }

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

335

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

337 ctx->trace_enable = trace;

338 if (err < 0)

339 return err;

340 }

341 }

342 #endif

343

344 return 0;

345 }

bit_position

#define bit_position(rw)

Definition: cbs_h2645.c:442

skip_bits_long

static void skip_bits_long(GetBitContext *s, int n)

Skips the specified number of bits.

Definition: get_bits.h:278

get_bits_left

static int get_bits_left(GetBitContext *gb)

Definition: get_bits.h:695

byte_alignment

#define byte_alignment(rw)

Definition: cbs_av1.c:653

SEIRawUserDataRegistered

Definition: cbs_sei.h:33

ff_ctz

#define ff_ctz

Definition: intmath.h:107

SEIRawAmbientViewingEnvironment

Definition: cbs_sei.h:64

message

Definition: api-threadmessage-test.c:46

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

Definition: cbs_h2645.c:250

SEIRawMessage

Definition: cbs_sei.h:70

get_bits_count

static int get_bits_count(const GetBitContext *s)

Definition: get_bits.h:266

HEADER

#define HEADER(name)

Definition: cbs_av1.c:456

tmp

static uint8_t tmp[11]

Definition: aes_ctr.c:28

CodedBitstreamContext

Context structure for coded bitstream operations.

Definition: cbs.h:219

data

const char data[16]

Definition: mxf.c:148

SEIRawAlternativeTransferCharacteristics

Definition: cbs_sei.h:60

allocate

#define allocate(name, size)

Definition: cbs_h2645.c:445

init_get_bits

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

Initialize GetBitContext.

Definition: get_bits.h:514

SEIRawContentLightLevelInfo

Definition: cbs_sei.h:55

get_bits

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

Read 1-25 bits.

Definition: get_bits.h:335

CHECK

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

SEIRawUserDataUnregistered::data

uint8_t * data

RefStruct reference.

Definition: cbs_sei.h:42

GetBitContext

Definition: get_bits.h:108

#define ub(width, name)

Definition: cbs_h2645.c:400

SEIRawUserDataUnregistered

Definition: cbs_sei.h:40

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

Definition: cbs_h2645.c:262

message_list

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

Definition: cbs_sei_syntax_template.c:253

SEIRawUserDataRegistered::itu_t_t35_country_code

uint8_t itu_t_t35_country_code

Definition: cbs_sei.h:34

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:180

SEIRawFillerPayload

Definition: cbs_sei.h:29

SEIRawMessageList

Definition: cbs_sei.h:79

SEIRawUserDataUnregistered::data_length

size_t data_length

Definition: cbs_sei.h:43

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:196

PutBitContext

Definition: put_bits.h:50

GetBitContext::buffer

const uint8_t * buffer

Definition: get_bits.h:109

bits_left

#define bits_left

Definition: bitstream.h:114

SEIMessageTypeDescriptor

Definition: cbs_sei.h:114

SEIRawMasteringDisplayColourVolume

Definition: cbs_sei.h:46

state

static struct @385 state

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

SEIRawFillerPayload::payload_size

uint32_t payload_size

Definition: cbs_sei.h:30

SEIRawUserDataRegistered::data

uint8_t * data

RefStruct reference.

Definition: cbs_sei.h:36

SEIRawUserDataRegistered::data_length

size_t data_length

Definition: cbs_sei.h:37

ff_cbs_sei_find_type