FFmpeg: libavcodec/cbs_av1.c Source File

FFmpeg

[フレーム]

libavcodec

cbs_av1.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 #include "libavutil/avassert.h"

20 #include "libavutil/opt.h"

21 #include "libavutil/pixfmt.h"

23 #include "avcodec.h"

24 #include "cbs.h"

25 #include "cbs_internal.h"

26 #include "cbs_av1.h"

29 static int cbs_av1_read_uvlc(CodedBitstreamContext *ctx, GetBitContext *gbc,

30 const char *name, uint32_t *write_to,

31 uint32_t range_min, uint32_t range_max)

32 {

33 uint32_t zeroes, bits_value, value;

34 int position;

36 if (ctx->trace_enable)

37 position = get_bits_count(gbc);

39 zeroes = 0;

40 while (1) {

41 if (get_bits_left(gbc) < 1) {

42 av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid uvlc code at "

43 "%s: bitstream ended.\n", name);

44 return AVERROR_INVALIDDATA;

45 }

47 if (get_bits1(gbc))

48 break;

49 ++zeroes;

50 }

52 if (zeroes >= 32) {

53 value = MAX_UINT_BITS(32);

54 } else {

55 if (get_bits_left(gbc) < zeroes) {

56 av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid uvlc code at "

57 "%s: bitstream ended.\n", name);

58 return AVERROR_INVALIDDATA;

59 }

61 bits_value = get_bits_long(gbc, zeroes);

62 value = bits_value + (UINT32_C(1) << zeroes) - 1;

63 }

65 if (ctx->trace_enable) {

66 char bits[65];

67 int i, j, k;

69 if (zeroes >= 32) {

70 while (zeroes > 32) {

71 k = FFMIN(zeroes - 32, 32);

72 for (i = 0; i < k; i++)

73 bits[i] = '0';

74 bits[i] = 0;

75 ff_cbs_trace_syntax_element(ctx, position, name,

76 NULL, bits, 0);

77 zeroes -= k;

78 position += k;

79 }

80 }

82 for (i = 0; i < zeroes; i++)

83 bits[i] = '0';

84 bits[i++] = '1';

86 if (zeroes < 32) {

87 for (j = 0; j < zeroes; j++)

88 bits[i++] = (bits_value >> (zeroes - j - 1) & 1) ? '1' : '0';

89 }

91 bits[i] = 0;

92 ff_cbs_trace_syntax_element(ctx, position, name,

93 NULL, bits, value);

94 }

96 if (value < range_min || value > range_max) {

97 av_log(ctx->log_ctx, AV_LOG_ERROR, "%s out of range: "

98 "%"PRIu32", but must be in [%"PRIu32",%"PRIu32"].\n",

99 name, value, range_min, range_max);

100 return AVERROR_INVALIDDATA;

101 }

102

103 *write_to = value;

104 return 0;

105 }

106

107 static int cbs_av1_write_uvlc(CodedBitstreamContext *ctx, PutBitContext *pbc,

108 const char *name, uint32_t value,

109 uint32_t range_min, uint32_t range_max)

110 {

111 uint32_t v;

112 int position, zeroes;

113

114 if (value < range_min || value > range_max) {

115 av_log(ctx->log_ctx, AV_LOG_ERROR, "%s out of range: "

116 "%"PRIu32", but must be in [%"PRIu32",%"PRIu32"].\n",

117 name, value, range_min, range_max);

118 return AVERROR_INVALIDDATA;

119 }

120

121 if (ctx->trace_enable)

122 position = put_bits_count(pbc);

123

124 zeroes = av_log2(value + 1);

125 v = value - (1U << zeroes) + 1;

126 put_bits(pbc, zeroes, 0);

127 put_bits(pbc, 1, 1);

128 put_bits(pbc, zeroes, v);

129

130 if (ctx->trace_enable) {

131 char bits[65];

132 int i, j;

133 i = 0;

134 for (j = 0; j < zeroes; j++)

135 bits[i++] = '0';

136 bits[i++] = '1';

137 for (j = 0; j < zeroes; j++)

138 bits[i++] = (v >> (zeroes - j - 1) & 1) ? '1' : '0';

139 bits[i++] = 0;

140 ff_cbs_trace_syntax_element(ctx, position, name, NULL,

141 bits, value);

142 }

143

144 return 0;

145 }

146

147 static int cbs_av1_read_leb128(CodedBitstreamContext *ctx, GetBitContext *gbc,

148 const char *name, uint64_t *write_to)

149 {

150 uint64_t value;

151 int position, err, i;

152

153 if (ctx->trace_enable)

154 position = get_bits_count(gbc);

155

156 value = 0;

157 for (i = 0; i < 8; i++) {

158 int subscript[2] = { 1, i };

159 uint32_t byte;

160 err = ff_cbs_read_unsigned(ctx, gbc, 8, "leb128_byte[i]", subscript,

161 &byte, 0x00, 0xff);

162 if (err < 0)

163 return err;

164

165 value |= (uint64_t)(byte & 0x7f) << (i * 7);

166 if (!(byte & 0x80))

167 break;

168 }

169

170 if (value > UINT32_MAX)

171 return AVERROR_INVALIDDATA;

172

173 if (ctx->trace_enable)

174 ff_cbs_trace_syntax_element(ctx, position, name, NULL, "", value);

175

176 *write_to = value;

177 return 0;

178 }

179

180 static int cbs_av1_write_leb128(CodedBitstreamContext *ctx, PutBitContext *pbc,

181 const char *name, uint64_t value)

182 {

183 int position, err, len, i;

184 uint8_t byte;

185

186 len = (av_log2(value) + 7) / 7;

187

188 if (ctx->trace_enable)

189 position = put_bits_count(pbc);

190

191 for (i = 0; i < len; i++) {

192 int subscript[2] = { 1, i };

193

194 byte = value >> (7 * i) & 0x7f;

195 if (i < len - 1)

196 byte |= 0x80;

197

198 err = ff_cbs_write_unsigned(ctx, pbc, 8, "leb128_byte[i]", subscript,

199 byte, 0x00, 0xff);

200 if (err < 0)

201 return err;

202 }

203

204 if (ctx->trace_enable)

205 ff_cbs_trace_syntax_element(ctx, position, name, NULL, "", value);

206

207 return 0;

208 }

209

210 static int cbs_av1_read_ns(CodedBitstreamContext *ctx, GetBitContext *gbc,

211 uint32_t n, const char *name,

212 const int *subscripts, uint32_t *write_to)

213 {

214 uint32_t m, v, extra_bit, value;

215 int position, w;

216

217 av_assert0(n > 0);

218

219 if (ctx->trace_enable)

220 position = get_bits_count(gbc);

221

222 w = av_log2(n) + 1;

223 m = (1 << w) - n;

224

225 if (get_bits_left(gbc) < w) {

226 av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid non-symmetric value at "

227 "%s: bitstream ended.\n", name);

228 return AVERROR_INVALIDDATA;

229 }

230

231 if (w - 1 > 0)

232 v = get_bits(gbc, w - 1);

233 else

234 v = 0;

235

236 if (v < m) {

237 value = v;

238 } else {

239 extra_bit = get_bits1(gbc);

240 value = (v << 1) - m + extra_bit;

241 }

242

243 if (ctx->trace_enable) {

244 char bits[33];

245 int i;

246 for (i = 0; i < w - 1; i++)

247 bits[i] = (v >> i & 1) ? '1' : '0';

248 if (v >= m)

249 bits[i++] = extra_bit ? '1' : '0';

250 bits[i] = 0;

251

252 ff_cbs_trace_syntax_element(ctx, position,

253 name, subscripts, bits, value);

254 }

255

256 *write_to = value;

257 return 0;

258 }

259

260 static int cbs_av1_write_ns(CodedBitstreamContext *ctx, PutBitContext *pbc,

261 uint32_t n, const char *name,

262 const int *subscripts, uint32_t value)

263 {

264 uint32_t w, m, v, extra_bit;

265 int position;

266

267 if (value > n) {

268 av_log(ctx->log_ctx, AV_LOG_ERROR, "%s out of range: "

269 "%"PRIu32", but must be in [0,%"PRIu32"].\n",

270 name, value, n);

271 return AVERROR_INVALIDDATA;

272 }

273

274 if (ctx->trace_enable)

275 position = put_bits_count(pbc);

276

277 w = av_log2(n) + 1;

278 m = (1 << w) - n;

279

280 if (put_bits_left(pbc) < w)

281 return AVERROR(ENOSPC);

282

283 if (value < m) {

284 v = value;

285 put_bits(pbc, w - 1, v);

286 } else {

287 v = m + ((value - m) >> 1);

288 extra_bit = (value - m) & 1;

289 put_bits(pbc, w - 1, v);

290 put_bits(pbc, 1, extra_bit);

291 }

292

293 if (ctx->trace_enable) {

294 char bits[33];

295 int i;

296 for (i = 0; i < w - 1; i++)

297 bits[i] = (v >> i & 1) ? '1' : '0';

298 if (value >= m)

299 bits[i++] = extra_bit ? '1' : '0';

300 bits[i] = 0;

301

302 ff_cbs_trace_syntax_element(ctx, position,

303 name, subscripts, bits, value);

304 }

305

306 return 0;

307 }

308

309 static int cbs_av1_read_increment(CodedBitstreamContext *ctx, GetBitContext *gbc,

310 uint32_t range_min, uint32_t range_max,

311 const char *name, uint32_t *write_to)

312 {

313 uint32_t value;

314 int position, i;

315 char bits[33];

316

317 av_assert0(range_min <= range_max && range_max - range_min < sizeof(bits) - 1);

318 if (ctx->trace_enable)

319 position = get_bits_count(gbc);

320

321 for (i = 0, value = range_min; value < range_max;) {

322 if (get_bits_left(gbc) < 1) {

323 av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid increment value at "

324 "%s: bitstream ended.\n", name);

325 return AVERROR_INVALIDDATA;

326 }

327 if (get_bits1(gbc)) {

328 bits[i++] = '1';

329 ++value;

330 } else {

331 bits[i++] = '0';

332 break;

333 }

334 }

335

336 if (ctx->trace_enable) {

337 bits[i] = 0;

338 ff_cbs_trace_syntax_element(ctx, position,

339 name, NULL, bits, value);

340 }

341

342 *write_to = value;

343 return 0;

344 }

345

346 static int cbs_av1_write_increment(CodedBitstreamContext *ctx, PutBitContext *pbc,

347 uint32_t range_min, uint32_t range_max,

348 const char *name, uint32_t value)

349 {

350 int len;

351

352 av_assert0(range_min <= range_max && range_max - range_min < 32);

353 if (value < range_min || value > range_max) {

354 av_log(ctx->log_ctx, AV_LOG_ERROR, "%s out of range: "

355 "%"PRIu32", but must be in [%"PRIu32",%"PRIu32"].\n",

356 name, value, range_min, range_max);

357 return AVERROR_INVALIDDATA;

358 }

359

360 if (value == range_max)

361 len = range_max - range_min;

362 else

363 len = value - range_min + 1;

364 if (put_bits_left(pbc) < len)

365 return AVERROR(ENOSPC);

366

367 if (ctx->trace_enable) {

368 char bits[33];

369 int i;

370 for (i = 0; i < len; i++) {

371 if (range_min + i == value)

372 bits[i] = '0';

373 else

374 bits[i] = '1';

375 }

376 bits[i] = 0;

377 ff_cbs_trace_syntax_element(ctx, put_bits_count(pbc),

378 name, NULL, bits, value);

379 }

380

381 if (len > 0)

382 put_bits(pbc, len, (1 << len) - 1 - (value != range_max));

383

384 return 0;

385 }

386

387 static int cbs_av1_read_subexp(CodedBitstreamContext *ctx, GetBitContext *gbc,

388 uint32_t range_max, const char *name,

389 const int *subscripts, uint32_t *write_to)

390 {

391 uint32_t value;

392 int position, err;

393 uint32_t max_len, len, range_offset, range_bits;

394

395 if (ctx->trace_enable)

396 position = get_bits_count(gbc);

397

398 av_assert0(range_max > 0);

399 max_len = av_log2(range_max - 1) - 3;

400

401 err = cbs_av1_read_increment(ctx, gbc, 0, max_len,

402 "subexp_more_bits", &len);

403 if (err < 0)

404 return err;

405

406 if (len) {

407 range_bits = 2 + len;

408 range_offset = 1 << range_bits;

409 } else {

410 range_bits = 3;

411 range_offset = 0;

412 }

413

414 if (len < max_len) {

415 err = ff_cbs_read_unsigned(ctx, gbc, range_bits,

416 "subexp_bits", NULL, &value,

417 0, MAX_UINT_BITS(range_bits));

418 if (err < 0)

419 return err;

420

421 } else {

422 err = cbs_av1_read_ns(ctx, gbc, range_max - range_offset,

423 "subexp_final_bits", NULL, &value);

424 if (err < 0)

425 return err;

426 }

427 value += range_offset;

428

429 if (ctx->trace_enable)

430 ff_cbs_trace_syntax_element(ctx, position,

431 name, subscripts, "", value);

432

433 *write_to = value;

434 return err;

435 }

436

437 static int cbs_av1_write_subexp(CodedBitstreamContext *ctx, PutBitContext *pbc,

438 uint32_t range_max, const char *name,

439 const int *subscripts, uint32_t value)

440 {

441 int position, err;

442 uint32_t max_len, len, range_offset, range_bits;

443

444 if (value > range_max) {

445 av_log(ctx->log_ctx, AV_LOG_ERROR, "%s out of range: "

446 "%"PRIu32", but must be in [0,%"PRIu32"].\n",

447 name, value, range_max);

448 return AVERROR_INVALIDDATA;

449 }

450

451 if (ctx->trace_enable)

452 position = put_bits_count(pbc);

453

454 av_assert0(range_max > 0);

455 max_len = av_log2(range_max - 1) - 3;

456

457 if (value < 8) {

458 range_bits = 3;

459 range_offset = 0;

460 len = 0;

461 } else {

462 range_bits = av_log2(value);

463 len = range_bits - 2;

464 if (len > max_len) {

465 // The top bin is combined with the one below it.

466 av_assert0(len == max_len + 1);

467 --range_bits;

468 len = max_len;

469 }

470 range_offset = 1 << range_bits;

471 }

472

473 err = cbs_av1_write_increment(ctx, pbc, 0, max_len,

474 "subexp_more_bits", len);

475 if (err < 0)

476 return err;

477

478 if (len < max_len) {

479 err = ff_cbs_write_unsigned(ctx, pbc, range_bits,

480 "subexp_bits", NULL,

481 value - range_offset,

482 0, MAX_UINT_BITS(range_bits));

483 if (err < 0)

484 return err;

485

486 } else {

487 err = cbs_av1_write_ns(ctx, pbc, range_max - range_offset,

488 "subexp_final_bits", NULL,

489 value - range_offset);

490 if (err < 0)

491 return err;

492 }

493

494 if (ctx->trace_enable)

495 ff_cbs_trace_syntax_element(ctx, position,

496 name, subscripts, "", value);

497

498 return err;

499 }

500

501

502 static int cbs_av1_tile_log2(int blksize, int target)

503 {

504 int k;

505 for (k = 0; (blksize << k) < target; k++);

506 return k;

507 }

508

509 static int cbs_av1_get_relative_dist(const AV1RawSequenceHeader *seq,

510 unsigned int a, unsigned int b)

511 {

512 unsigned int diff, m;

513 if (!seq->enable_order_hint)

514 return 0;

515 diff = a - b;

516 m = 1 << seq->order_hint_bits_minus_1;

517 diff = (diff & (m - 1)) - (diff & m);

518 return diff;

519 }

520

521 static size_t cbs_av1_get_payload_bytes_left(GetBitContext *gbc)

522 {

523 GetBitContext tmp = *gbc;

524 size_t size = 0;

525 for (int i = 0; get_bits_left(&tmp) >= 8; i++) {

526 if (get_bits(&tmp, 8))

527 size = i;

528 }

529 return size;

530 }

531

532

533 #define HEADER(name) do { \

534 ff_cbs_trace_header(ctx, name); \

535 } while (0)

536

537 #define CHECK(call) do { \

538 err = (call); \

539 if (err < 0) \

540 return err; \

541 } while (0)

542

543 #define FUNC_NAME(rw, codec, name) cbs_ ## codec ## _ ## rw ## _ ## name

544 #define FUNC_AV1(rw, name) FUNC_NAME(rw, av1, name)

545 #define FUNC(name) FUNC_AV1(READWRITE, name)

546

547 #define SUBSCRIPTS(subs, ...) (subs > 0 ? ((int[subs + 1]){ subs, __VA_ARGS__ }) : NULL)

548

549 #define fb(width, name) \

550 xf(width, name, current->name, 0, MAX_UINT_BITS(width), 0, )

551 #define fc(width, name, range_min, range_max) \

552 xf(width, name, current->name, range_min, range_max, 0, )

553 #define flag(name) fb(1, name)

554 #define su(width, name) \

555 xsu(width, name, current->name, 0, )

556

557 #define fbs(width, name, subs, ...) \

558 xf(width, name, current->name, 0, MAX_UINT_BITS(width), subs, __VA_ARGS__)

559 #define fcs(width, name, range_min, range_max, subs, ...) \

560 xf(width, name, current->name, range_min, range_max, subs, __VA_ARGS__)

561 #define flags(name, subs, ...) \

562 xf(1, name, current->name, 0, 1, subs, __VA_ARGS__)

563 #define sus(width, name, subs, ...) \

564 xsu(width, name, current->name, subs, __VA_ARGS__)

565

566 #define fixed(width, name, value) do { \

567 av_unused uint32_t fixed_value = value; \

568 xf(width, name, fixed_value, value, value, 0, ); \

569 } while (0)

570

571

572 #define READ

573 #define READWRITE read

574 #define RWContext GetBitContext

575

576 #define xf(width, name, var, range_min, range_max, subs, ...) do { \

577 uint32_t value; \

578 CHECK(ff_cbs_read_unsigned(ctx, rw, width, #name, \

579 SUBSCRIPTS(subs, __VA_ARGS__), \

580 &value, range_min, range_max)); \

581 var = value; \

582 } while (0)

583

584 #define xsu(width, name, var, subs, ...) do { \

585 int32_t value; \

586 CHECK(ff_cbs_read_signed(ctx, rw, width, #name, \

587 SUBSCRIPTS(subs, __VA_ARGS__), &value, \

588 MIN_INT_BITS(width), \

589 MAX_INT_BITS(width))); \

590 var = value; \

591 } while (0)

592

593 #define uvlc(name, range_min, range_max) do { \

594 uint32_t value; \

595 CHECK(cbs_av1_read_uvlc(ctx, rw, #name, \

596 &value, range_min, range_max)); \

597 current->name = value; \

598 } while (0)

599

600 #define ns(max_value, name, subs, ...) do { \

601 uint32_t value; \

602 CHECK(cbs_av1_read_ns(ctx, rw, max_value, #name, \

603 SUBSCRIPTS(subs, __VA_ARGS__), &value)); \

604 current->name = value; \

605 } while (0)

606

607 #define increment(name, min, max) do { \

608 uint32_t value; \

609 CHECK(cbs_av1_read_increment(ctx, rw, min, max, #name, &value)); \

610 current->name = value; \

611 } while (0)

612

613 #define subexp(name, max, subs, ...) do { \

614 uint32_t value; \

615 CHECK(cbs_av1_read_subexp(ctx, rw, max, #name, \

616 SUBSCRIPTS(subs, __VA_ARGS__), &value)); \

617 current->name = value; \

618 } while (0)

619

620 #define delta_q(name) do { \

621 uint8_t delta_coded; \

622 int8_t delta_q; \

623 xf(1, name.delta_coded, delta_coded, 0, 1, 0, ); \

624 if (delta_coded) \

625 xsu(1 + 6, name.delta_q, delta_q, 0, ); \

626 else \

627 delta_q = 0; \

628 current->name = delta_q; \

629 } while (0)

630

631 #define leb128(name) do { \

632 uint64_t value; \

633 CHECK(cbs_av1_read_leb128(ctx, rw, #name, &value)); \

634 current->name = value; \

635 } while (0)

636

637 #define infer(name, value) do { \

638 current->name = value; \

639 } while (0)

640

641 #define byte_alignment(rw) (get_bits_count(rw) % 8)

642

643 #include "cbs_av1_syntax_template.c"

644

645 #undef READ

646 #undef READWRITE

647 #undef RWContext

648 #undef xf

649 #undef xsu

650 #undef uvlc

651 #undef ns

652 #undef increment

653 #undef subexp

654 #undef delta_q

655 #undef leb128

656 #undef infer

657 #undef byte_alignment

658

659

660 #define WRITE

661 #define READWRITE write

662 #define RWContext PutBitContext

663

664 #define xf(width, name, var, range_min, range_max, subs, ...) do { \

665 CHECK(ff_cbs_write_unsigned(ctx, rw, width, #name, \

666 SUBSCRIPTS(subs, __VA_ARGS__), \

667 var, range_min, range_max)); \

668 } while (0)

669

670 #define xsu(width, name, var, subs, ...) do { \

671 CHECK(ff_cbs_write_signed(ctx, rw, width, #name, \

672 SUBSCRIPTS(subs, __VA_ARGS__), var, \

673 MIN_INT_BITS(width), \

674 MAX_INT_BITS(width))); \

675 } while (0)

676

677 #define uvlc(name, range_min, range_max) do { \

678 CHECK(cbs_av1_write_uvlc(ctx, rw, #name, current->name, \

679 range_min, range_max)); \

680 } while (0)

681

682 #define ns(max_value, name, subs, ...) do { \

683 CHECK(cbs_av1_write_ns(ctx, rw, max_value, #name, \

684 SUBSCRIPTS(subs, __VA_ARGS__), \

685 current->name)); \

686 } while (0)

687

688 #define increment(name, min, max) do { \

689 CHECK(cbs_av1_write_increment(ctx, rw, min, max, #name, \

690 current->name)); \

691 } while (0)

692

693 #define subexp(name, max, subs, ...) do { \

694 CHECK(cbs_av1_write_subexp(ctx, rw, max, #name, \

695 SUBSCRIPTS(subs, __VA_ARGS__), \

696 current->name)); \

697 } while (0)

698

699 #define delta_q(name) do { \

700 xf(1, name.delta_coded, current->name != 0, 0, 1, 0, ); \

701 if (current->name) \

702 xsu(1 + 6, name.delta_q, current->name, 0, ); \

703 } while (0)

704

705 #define leb128(name) do { \

706 CHECK(cbs_av1_write_leb128(ctx, rw, #name, current->name)); \

707 } while (0)

708

709 #define infer(name, value) do { \

710 if (current->name != (value)) { \

711 av_log(ctx->log_ctx, AV_LOG_ERROR, \

712 "%s does not match inferred value: " \

713 "%"PRId64", but should be %"PRId64".\n", \

714 #name, (int64_t)current->name, (int64_t)(value)); \

715 return AVERROR_INVALIDDATA; \

716 } \

717 } while (0)

718

719 #define byte_alignment(rw) (put_bits_count(rw) % 8)

720

721 #include "cbs_av1_syntax_template.c"

722

723 #undef WRITE

724 #undef READWRITE

725 #undef RWContext

726 #undef xf

727 #undef xsu

728 #undef uvlc

729 #undef ns

730 #undef increment

731 #undef subexp

732 #undef delta_q

733 #undef leb128

734 #undef infer

735 #undef byte_alignment

736

737

738 static int cbs_av1_split_fragment(CodedBitstreamContext *ctx,

739 CodedBitstreamFragment *frag,

740 int header)

741 {

742 GetBitContext gbc;

743 uint8_t *data;

744 size_t size;

745 uint64_t obu_length;

746 int pos, err, trace;

747

748 // Don't include this parsing in trace output.

749 trace = ctx->trace_enable;

750 ctx->trace_enable = 0;

751

752 data = frag->data;

753 size = frag->data_size;

754

755 if (INT_MAX / 8 < size) {

756 av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid fragment: "

757 "too large (%"SIZE_SPECIFIER " bytes).\n", size);

758 err = AVERROR_INVALIDDATA;

759 goto fail;

760 }

761

762 if (header && size && data[0] & 0x80) {

763 // first bit is nonzero, the extradata does not consist purely of

764 // OBUs. Expect MP4/Matroska AV1CodecConfigurationRecord

765 int config_record_version = data[0] & 0x7f;

766

767 if (config_record_version != 1) {

768 av_log(ctx->log_ctx, AV_LOG_ERROR,

769 "Unknown version %d of AV1CodecConfigurationRecord "

770 "found!\n",

771 config_record_version);

772 err = AVERROR_INVALIDDATA;

773 goto fail;

774 }

775

776 if (size <= 4) {

777 if (size < 4) {

778 av_log(ctx->log_ctx, AV_LOG_WARNING,

779 "Undersized AV1CodecConfigurationRecord v%d found!\n",

780 config_record_version);

781 err = AVERROR_INVALIDDATA;

782 goto fail;

783 }

784

785 goto success;

786 }

787

788 // In AV1CodecConfigurationRecord v1, actual OBUs start after

789 // four bytes. Thus set the offset as required for properly

790 // parsing them.

791 data += 4;

792 size -= 4;

793 }

794

795 while (size > 0) {

796 AV1RawOBUHeader header;

797 uint64_t obu_size;

798

799 init_get_bits(&gbc, data, 8 * size);

800

801 err = cbs_av1_read_obu_header(ctx, &gbc, &header);

802 if (err < 0)

803 goto fail;

804

805 if (header.obu_has_size_field) {

806 if (get_bits_left(&gbc) < 8) {

807 av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid OBU: fragment "

808 "too short (%"SIZE_SPECIFIER " bytes).\n", size);

809 err = AVERROR_INVALIDDATA;

810 goto fail;

811 }

812 err = cbs_av1_read_leb128(ctx, &gbc, "obu_size", &obu_size);

813 if (err < 0)

814 goto fail;

815 } else

816 obu_size = size - 1 - header.obu_extension_flag;

817

818 pos = get_bits_count(&gbc);

819 av_assert0(pos % 8 == 0 && pos / 8 <= size);

820

821 obu_length = pos / 8 + obu_size;

822

823 if (size < obu_length) {

824 av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid OBU length: "

825 "%"PRIu64", but only %"SIZE_SPECIFIER " bytes remaining in fragment.\n",

826 obu_length, size);

827 err = AVERROR_INVALIDDATA;

828 goto fail;

829 }

830

831 err = ff_cbs_append_unit_data(frag, header.obu_type,

832 data, obu_length, frag->data_ref);

833 if (err < 0)

834 goto fail;

835

836 data += obu_length;

837 size -= obu_length;

838 }

839

840 success:

841 err = 0;

842 fail:

843 ctx->trace_enable = trace;

844 return err;

845 }

846

847 static int cbs_av1_ref_tile_data(CodedBitstreamContext *ctx,

848 CodedBitstreamUnit *unit,

849 GetBitContext *gbc,

850 AV1RawTileData *td)

851 {

852 int pos;

853

854 pos = get_bits_count(gbc);

855 if (pos >= 8 * unit->data_size) {

856 av_log(ctx->log_ctx, AV_LOG_ERROR, "Bitstream ended before "

857 "any data in tile group (%d bits read).\n", pos);

858 return AVERROR_INVALIDDATA;

859 }

860 // Must be byte-aligned at this point.

861 av_assert0(pos % 8 == 0);

862

863 td->data_ref = av_buffer_ref(unit->data_ref);

864 if (!td->data_ref)

865 return AVERROR(ENOMEM);

866

867 td->data = unit->data + pos / 8;

868 td->data_size = unit->data_size - pos / 8;

869

870 return 0;

871 }

872

873 static int cbs_av1_read_unit(CodedBitstreamContext *ctx,

874 CodedBitstreamUnit *unit)

875 {

876 CodedBitstreamAV1Context *priv = ctx->priv_data;

877 AV1RawOBU *obu;

878 GetBitContext gbc;

879 int err, start_pos, end_pos;

880

881 err = ff_cbs_alloc_unit_content(ctx, unit);

882 if (err < 0)

883 return err;

884 obu = unit->content;

885

886 err = init_get_bits(&gbc, unit->data, 8 * unit->data_size);

887 if (err < 0)

888 return err;

889

890 err = cbs_av1_read_obu_header(ctx, &gbc, &obu->header);

891 if (err < 0)

892 return err;

893 av_assert0(obu->header.obu_type == unit->type);

894

895 if (obu->header.obu_has_size_field) {

896 uint64_t obu_size;

897 err = cbs_av1_read_leb128(ctx, &gbc, "obu_size", &obu_size);

898 if (err < 0)

899 return err;

900 obu->obu_size = obu_size;

901 } else {

902 if (unit->data_size < 1 + obu->header.obu_extension_flag) {

903 av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid OBU length: "

904 "unit too short (%"SIZE_SPECIFIER ").\n", unit->data_size);

905 return AVERROR_INVALIDDATA;

906 }

907 obu->obu_size = unit->data_size - 1 - obu->header.obu_extension_flag;

908 }

909

910 start_pos = get_bits_count(&gbc);

911

912 if (obu->header.obu_extension_flag) {

913 if (obu->header.obu_type != AV1_OBU_SEQUENCE_HEADER &&

914 obu->header.obu_type != AV1_OBU_TEMPORAL_DELIMITER &&

915 priv->operating_point_idc) {

916 int in_temporal_layer =

917 (priv->operating_point_idc >> priv->temporal_id ) & 1;

918 int in_spatial_layer =

919 (priv->operating_point_idc >> (priv->spatial_id + 8)) & 1;

920 if (!in_temporal_layer || !in_spatial_layer) {

921 return AVERROR(EAGAIN); // drop_obu()

922 }

923 }

924 }

925

926 switch (obu->header.obu_type) {

927 case AV1_OBU_SEQUENCE_HEADER:

928 {

929 err = cbs_av1_read_sequence_header_obu(ctx, &gbc,

930 &obu->obu.sequence_header);

931 if (err < 0)

932 return err;

933

934 if (priv->operating_point >= 0) {

935 AV1RawSequenceHeader *sequence_header = &obu->obu.sequence_header;

936

937 if (priv->operating_point > sequence_header->operating_points_cnt_minus_1) {

938 av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid Operating Point %d requested. "

939 "Must not be higher than %u.\n",

940 priv->operating_point, sequence_header->operating_points_cnt_minus_1);

941 return AVERROR(EINVAL);

942 }

943 priv->operating_point_idc = sequence_header->operating_point_idc[priv->operating_point];

944 }

945

946 av_buffer_unref(&priv->sequence_header_ref);

947 priv->sequence_header = NULL;

948

949 priv->sequence_header_ref = av_buffer_ref(unit->content_ref);

950 if (!priv->sequence_header_ref)

951 return AVERROR(ENOMEM);

952 priv->sequence_header = &obu->obu.sequence_header;

953 }

954 break;

955 case AV1_OBU_TEMPORAL_DELIMITER:

956 {

957 err = cbs_av1_read_temporal_delimiter_obu(ctx, &gbc);

958 if (err < 0)

959 return err;

960 }

961 break;

962 case AV1_OBU_FRAME_HEADER:

963 case AV1_OBU_REDUNDANT_FRAME_HEADER:

964 {

965 err = cbs_av1_read_frame_header_obu(ctx, &gbc,

966 &obu->obu.frame_header,

967 obu->header.obu_type ==

968 AV1_OBU_REDUNDANT_FRAME_HEADER,

969 unit->data_ref);

970 if (err < 0)

971 return err;

972 }

973 break;

974 case AV1_OBU_TILE_GROUP:

975 {

976 err = cbs_av1_read_tile_group_obu(ctx, &gbc,

977 &obu->obu.tile_group);

978 if (err < 0)

979 return err;

980

981 err = cbs_av1_ref_tile_data(ctx, unit, &gbc,

982 &obu->obu.tile_group.tile_data);

983 if (err < 0)

984 return err;

985 }

986 break;

987 case AV1_OBU_FRAME:

988 {

989 err = cbs_av1_read_frame_obu(ctx, &gbc, &obu->obu.frame,

990 unit->data_ref);

991 if (err < 0)

992 return err;

993

994 err = cbs_av1_ref_tile_data(ctx, unit, &gbc,

995 &obu->obu.frame.tile_group.tile_data);

996 if (err < 0)

997 return err;

998 }

999 break;

1000 case AV1_OBU_TILE_LIST:

1001 {

1002 err = cbs_av1_read_tile_list_obu(ctx, &gbc,

1003 &obu->obu.tile_list);

1004 if (err < 0)

1005 return err;

1006

1007 err = cbs_av1_ref_tile_data(ctx, unit, &gbc,

1008 &obu->obu.tile_list.tile_data);

1009 if (err < 0)

1010 return err;

1011 }

1012 break;

1013 case AV1_OBU_METADATA:

1014 {

1015 err = cbs_av1_read_metadata_obu(ctx, &gbc, &obu->obu.metadata);

1016 if (err < 0)

1017 return err;

1018 }

1019 break;

1020 case AV1_OBU_PADDING:

1021 {

1022 err = cbs_av1_read_padding_obu(ctx, &gbc, &obu->obu.padding);

1023 if (err < 0)

1024 return err;

1025 }

1026 break;

1027 default:

1028 return AVERROR(ENOSYS);

1029 }

1030

1031 end_pos = get_bits_count(&gbc);

1032 av_assert0(end_pos <= unit->data_size * 8);

1033

1034 if (obu->obu_size > 0 &&

1035 obu->header.obu_type != AV1_OBU_TILE_GROUP &&

1036 obu->header.obu_type != AV1_OBU_TILE_LIST &&

1037 obu->header.obu_type != AV1_OBU_FRAME) {

1038 int nb_bits = obu->obu_size * 8 + start_pos - end_pos;

1039

1040 if (nb_bits <= 0)

1041 return AVERROR_INVALIDDATA;

1042

1043 err = cbs_av1_read_trailing_bits(ctx, &gbc, nb_bits);

1044 if (err < 0)

1045 return err;

1046 }

1047

1048 return 0;

1049 }

1050

1051 static int cbs_av1_write_obu(CodedBitstreamContext *ctx,

1052 CodedBitstreamUnit *unit,

1053 PutBitContext *pbc)

1054 {

1055 CodedBitstreamAV1Context *priv = ctx->priv_data;

1056 AV1RawOBU *obu = unit->content;

1057 PutBitContext pbc_tmp;

1058 AV1RawTileData *td;

1059 size_t header_size;

1060 int err, start_pos, end_pos, data_pos;

1061 CodedBitstreamAV1Context av1ctx;

1062

1063 // OBUs in the normal bitstream format must contain a size field

1064 // in every OBU (in annex B it is optional, but we don't support

1065 // writing that).

1066 obu->header.obu_has_size_field = 1;

1067 av1ctx = *priv;

1068

1069 if (priv->sequence_header_ref) {

1070 av1ctx.sequence_header_ref = av_buffer_ref(priv->sequence_header_ref);

1071 if (!av1ctx.sequence_header_ref)

1072 return AVERROR(ENOMEM);

1073 }

1074

1075 if (priv->frame_header_ref) {

1076 av1ctx.frame_header_ref = av_buffer_ref(priv->frame_header_ref);

1077 if (!av1ctx.frame_header_ref) {

1078 err = AVERROR(ENOMEM);

1079 goto error;

1080 }

1081 }

1082

1083 err = cbs_av1_write_obu_header(ctx, pbc, &obu->header);

1084 if (err < 0)

1085 goto error;

1086

1087 if (obu->header.obu_has_size_field) {

1088 pbc_tmp = *pbc;

1089 // Add space for the size field to fill later.

1090 put_bits32(pbc, 0);

1091 put_bits32(pbc, 0);

1092 }

1093

1094 td = NULL;

1095 start_pos = put_bits_count(pbc);

1096

1097 switch (obu->header.obu_type) {

1098 case AV1_OBU_SEQUENCE_HEADER:

1099 {

1100 err = cbs_av1_write_sequence_header_obu(ctx, pbc,

1101 &obu->obu.sequence_header);

1102 if (err < 0)

1103 goto error;

1104

1105 av_buffer_unref(&priv->sequence_header_ref);

1106 priv->sequence_header = NULL;

1107

1108 err = ff_cbs_make_unit_refcounted(ctx, unit);

1109 if (err < 0)

1110 goto error;

1111

1112 priv->sequence_header_ref = av_buffer_ref(unit->content_ref);

1113 if (!priv->sequence_header_ref) {

1114 err = AVERROR(ENOMEM);

1115 goto error;

1116 }

1117

1118 priv->sequence_header = &obu->obu.sequence_header;

1119 }

1120 break;

1121 case AV1_OBU_TEMPORAL_DELIMITER:

1122 {

1123 err = cbs_av1_write_temporal_delimiter_obu(ctx, pbc);

1124 if (err < 0)

1125 goto error;

1126 }

1127 break;

1128 case AV1_OBU_FRAME_HEADER:

1129 case AV1_OBU_REDUNDANT_FRAME_HEADER:

1130 {

1131 err = cbs_av1_write_frame_header_obu(ctx, pbc,

1132 &obu->obu.frame_header,

1133 obu->header.obu_type ==

1134 AV1_OBU_REDUNDANT_FRAME_HEADER,

1135 NULL);

1136 if (err < 0)

1137 goto error;

1138 }

1139 break;

1140 case AV1_OBU_TILE_GROUP:

1141 {

1142 err = cbs_av1_write_tile_group_obu(ctx, pbc,

1143 &obu->obu.tile_group);

1144 if (err < 0)

1145 goto error;

1146

1147 td = &obu->obu.tile_group.tile_data;

1148 }

1149 break;

1150 case AV1_OBU_FRAME:

1151 {

1152 err = cbs_av1_write_frame_obu(ctx, pbc, &obu->obu.frame, NULL);

1153 if (err < 0)

1154 goto error;

1155

1156 td = &obu->obu.frame.tile_group.tile_data;

1157 }

1158 break;

1159 case AV1_OBU_TILE_LIST:

1160 {

1161 err = cbs_av1_write_tile_list_obu(ctx, pbc, &obu->obu.tile_list);

1162 if (err < 0)

1163 goto error;

1164

1165 td = &obu->obu.tile_list.tile_data;

1166 }

1167 break;

1168 case AV1_OBU_METADATA:

1169 {

1170 err = cbs_av1_write_metadata_obu(ctx, pbc, &obu->obu.metadata);

1171 if (err < 0)

1172 goto error;

1173 }

1174 break;

1175 case AV1_OBU_PADDING:

1176 {

1177 err = cbs_av1_write_padding_obu(ctx, pbc, &obu->obu.padding);

1178 if (err < 0)

1179 goto error;

1180 }

1181 break;

1182 default:

1183 err = AVERROR(ENOSYS);

1184 goto error;

1185 }

1186

1187 end_pos = put_bits_count(pbc);

1188 header_size = (end_pos - start_pos + 7) / 8;

1189 if (td) {

1190 obu->obu_size = header_size + td->data_size;

1191 } else if (header_size > 0) {

1192 // Add trailing bits and recalculate.

1193 err = cbs_av1_write_trailing_bits(ctx, pbc, 8 - end_pos % 8);

1194 if (err < 0)

1195 goto error;

1196 end_pos = put_bits_count(pbc);

1197 obu->obu_size = header_size = (end_pos - start_pos + 7) / 8;

1198 } else {

1199 // Empty OBU.

1200 obu->obu_size = 0;

1201 }

1202

1203 end_pos = put_bits_count(pbc);

1204 // Must now be byte-aligned.

1205 av_assert0(end_pos % 8 == 0);

1206 flush_put_bits(pbc);

1207 start_pos /= 8;

1208 end_pos /= 8;

1209

1210 *pbc = pbc_tmp;

1211 err = cbs_av1_write_leb128(ctx, pbc, "obu_size", obu->obu_size);

1212 if (err < 0)

1213 goto error;

1214

1215 data_pos = put_bits_count(pbc) / 8;

1216 flush_put_bits(pbc);

1217 av_assert0(data_pos <= start_pos);

1218

1219 if (8 * obu->obu_size > put_bits_left(pbc)) {

1220 av_buffer_unref(&priv->sequence_header_ref);

1221 av_buffer_unref(&priv->frame_header_ref);

1222 *priv = av1ctx;

1223

1224 return AVERROR(ENOSPC);

1225 }

1226

1227 if (obu->obu_size > 0) {

1228 memmove(pbc->buf + data_pos,

1229 pbc->buf + start_pos, header_size);

1230 skip_put_bytes(pbc, header_size);

1231

1232 if (td) {

1233 memcpy(pbc->buf + data_pos + header_size,

1234 td->data, td->data_size);

1235 skip_put_bytes(pbc, td->data_size);

1236 }

1237 }

1238

1239 // OBU data must be byte-aligned.

1240 av_assert0(put_bits_count(pbc) % 8 == 0);

1241 err = 0;

1242

1243 error:

1244 av_buffer_unref(&av1ctx.sequence_header_ref);

1245 av_buffer_unref(&av1ctx.frame_header_ref);

1246

1247 return err;

1248 }

1249

1250 static int cbs_av1_assemble_fragment(CodedBitstreamContext *ctx,

1251 CodedBitstreamFragment *frag)

1252 {

1253 size_t size, pos;

1254 int i;

1255

1256 size = 0;

1257 for (i = 0; i < frag->nb_units; i++)

1258 size += frag->units[i].data_size;

1259

1260 frag->data_ref = av_buffer_alloc(size + AV_INPUT_BUFFER_PADDING_SIZE);

1261 if (!frag->data_ref)

1262 return AVERROR(ENOMEM);

1263 frag->data = frag->data_ref->data;

1264 memset(frag->data + size, 0, AV_INPUT_BUFFER_PADDING_SIZE);

1265

1266 pos = 0;

1267 for (i = 0; i < frag->nb_units; i++) {

1268 memcpy(frag->data + pos, frag->units[i].data,

1269 frag->units[i].data_size);

1270 pos += frag->units[i].data_size;

1271 }

1272 av_assert0(pos == size);

1273 frag->data_size = size;

1274

1275 return 0;

1276 }

1277

1278 static void cbs_av1_flush(CodedBitstreamContext *ctx)

1279 {

1280 CodedBitstreamAV1Context *priv = ctx->priv_data;

1281

1282 av_buffer_unref(&priv->frame_header_ref);

1283 priv->sequence_header = NULL;

1284 priv->frame_header = NULL;

1285

1286 memset(priv->ref, 0, sizeof(priv->ref));

1287 priv->operating_point_idc = 0;

1288 priv->seen_frame_header = 0;

1289 priv->tile_num = 0;

1290 }

1291

1292 static void cbs_av1_close(CodedBitstreamContext *ctx)

1293 {

1294 CodedBitstreamAV1Context *priv = ctx->priv_data;

1295

1296 av_buffer_unref(&priv->sequence_header_ref);

1297 av_buffer_unref(&priv->frame_header_ref);

1298 }

1299

1300 static void cbs_av1_free_metadata(void *unit, uint8_t *content)

1301 {

1302 AV1RawOBU *obu = (AV1RawOBU*)content;

1303 AV1RawMetadata *md;

1304

1305 av_assert0(obu->header.obu_type == AV1_OBU_METADATA);

1306 md = &obu->obu.metadata;

1307

1308 switch (md->metadata_type) {

1309 case AV1_METADATA_TYPE_ITUT_T35:

1310 av_buffer_unref(&md->metadata.itut_t35.payload_ref);

1311 break;

1312 }

1313 av_free(content);

1314 }

1315

1316 static const CodedBitstreamUnitTypeDescriptor cbs_av1_unit_types[] = {

1317 CBS_UNIT_TYPE_POD(AV1_OBU_SEQUENCE_HEADER, AV1RawOBU),

1318 CBS_UNIT_TYPE_POD(AV1_OBU_TEMPORAL_DELIMITER, AV1RawOBU),

1319 CBS_UNIT_TYPE_POD(AV1_OBU_FRAME_HEADER, AV1RawOBU),

1320 CBS_UNIT_TYPE_POD(AV1_OBU_REDUNDANT_FRAME_HEADER, AV1RawOBU),

1321

1322 CBS_UNIT_TYPE_INTERNAL_REF(AV1_OBU_TILE_GROUP, AV1RawOBU,

1323 obu.tile_group.tile_data.data),

1324 CBS_UNIT_TYPE_INTERNAL_REF(AV1_OBU_FRAME, AV1RawOBU,

1325 obu.frame.tile_group.tile_data.data),

1326 CBS_UNIT_TYPE_INTERNAL_REF(AV1_OBU_TILE_LIST, AV1RawOBU,

1327 obu.tile_list.tile_data.data),

1328 CBS_UNIT_TYPE_INTERNAL_REF(AV1_OBU_PADDING, AV1RawOBU,

1329 obu.padding.payload),

1330

1331 CBS_UNIT_TYPE_COMPLEX(AV1_OBU_METADATA, AV1RawOBU,

1332 &cbs_av1_free_metadata),

1333

1334 CBS_UNIT_TYPE_END_OF_LIST

1335 };

1336

1337 #define OFFSET(x) offsetof(CodedBitstreamAV1Context, x)

1338 static const AVOption cbs_av1_options[] = {

1339 { "operating_point", "Set operating point to select layers to parse from a scalable bitstream",

1340 OFFSET(operating_point), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, AV1_MAX_OPERATING_POINTS - 1, 0 },

1341 { NULL }

1342 };

1343

1344 static const AVClass cbs_av1_class = {

1345 .class_name = "cbs_av1",

1346 .item_name = av_default_item_name,

1347 .option = cbs_av1_options,

1348 .version = LIBAVUTIL_VERSION_INT,

1349 };

1350

1351 const CodedBitstreamType ff_cbs_type_av1 = {

1352 .codec_id = AV_CODEC_ID_AV1,

1353

1354 .priv_class = &cbs_av1_class,

1355 .priv_data_size = sizeof(CodedBitstreamAV1Context),

1356

1357 .unit_types = cbs_av1_unit_types,

1358

1359 .split_fragment = &cbs_av1_split_fragment,

1360 .read_unit = &cbs_av1_read_unit,

1361 .write_unit = &cbs_av1_write_obu,

1362 .assemble_fragment = &cbs_av1_assemble_fragment,

1363

1364 .flush = &cbs_av1_flush,

1365 .close = &cbs_av1_close,

1366 };

error

static void error(const char *err)

Definition: target_bsf_fuzzer.c:31

AV_LOG_WARNING

#define AV_LOG_WARNING

Something somehow does not look correct.

Definition: log.h:186

#define td

Definition: regdef.h:70

name

it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default minimum maximum flags name is the option name

Definition: writing_filters.txt:88

CBS_UNIT_TYPE_COMPLEX

#define CBS_UNIT_TYPE_COMPLEX(type, structure, free_func)

Definition: cbs_internal.h:239

AV1_OBU_REDUNDANT_FRAME_HEADER

@ AV1_OBU_REDUNDANT_FRAME_HEADER

Definition: av1.h:36

cbs_av1_class

static const AVClass cbs_av1_class

Definition: cbs_av1.c:1344

cbs_av1_unit_types

static const CodedBitstreamUnitTypeDescriptor cbs_av1_unit_types[]

Definition: cbs_av1.c:1316

CodedBitstreamAV1Context::operating_point

int operating_point

Definition: cbs_av1.h:460

get_bits_left

static int get_bits_left(GetBitContext *gb)

Definition: get_bits.h:664

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

opt.h

put_bits32

static void av_unused put_bits32(PutBitContext *s, uint32_t value)

Write exactly 32 bits into a bitstream.

Definition: put_bits.h:291

CodedBitstreamAV1Context::seen_frame_header

int seen_frame_header

Definition: cbs_av1.h:433

AV1RawSequenceHeader

Definition: cbs_av1.h:73

cbs_av1_write_increment

static int cbs_av1_write_increment(CodedBitstreamContext *ctx, PutBitContext *pbc, uint32_t range_min, uint32_t range_max, const char *name, uint32_t value)

Definition: cbs_av1.c:346

CodedBitstreamType::close

void(* close)(CodedBitstreamContext *ctx)

Definition: cbs_internal.h:145

AVBufferRef::data

uint8_t * data

The data buffer.

Definition: buffer.h:90

get_bits_long

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

Read 0-32 bits.

Definition: get_bits.h:411

CodedBitstreamUnit::content

void * content

Pointer to the decomposed form of this unit.

Definition: cbs.h:106

get_bits_count

static int get_bits_count(const GetBitContext *s)

Definition: get_bits.h:256

cbs_av1_free_metadata

static void cbs_av1_free_metadata(void *unit, uint8_t *content)

Definition: cbs_av1.c:1300

#define md

Definition: vf_colormatrix.c:103

CodedBitstreamAV1Context::tile_num

int tile_num

Definition: cbs_av1.h:455

tmp

static uint8_t tmp[11]

Definition: aes_ctr.c:28

put_bits

static void put_bits(Jpeg2000EncoderContext *s, int val, int n)

put n times val bit

Definition: j2kenc.c:221

uint8_t w

Definition: llviddspenc.c:38

cbs_av1_read_increment

static int cbs_av1_read_increment(CodedBitstreamContext *ctx, GetBitContext *gbc, uint32_t range_min, uint32_t range_max, const char *name, uint32_t *write_to)

Definition: cbs_av1.c:309

AV1_METADATA_TYPE_ITUT_T35

@ AV1_METADATA_TYPE_ITUT_T35

Definition: av1.h:47

CodedBitstreamContext

Context structure for coded bitstream operations.

Definition: cbs.h:173

CodedBitstreamAV1Context::frame_header_ref

AVBufferRef * frame_header_ref

Definition: cbs_av1.h:434

AVOption

AVOption.

Definition: opt.h:251

#define b

Definition: input.c:41

data

const char data[16]

Definition: mxf.c:146

cbs_av1_read_leb128

static int cbs_av1_read_leb128(CodedBitstreamContext *ctx, GetBitContext *gbc, const char *name, uint64_t *write_to)

Definition: cbs_av1.c:147

cbs_av1_read_ns

static int cbs_av1_read_ns(CodedBitstreamContext *ctx, GetBitContext *gbc, uint32_t n, const char *name, const int *subscripts, uint32_t *write_to)

Definition: cbs_av1.c:210

CodedBitstreamUnit::type

CodedBitstreamUnitType type

Codec-specific type of this unit.

Definition: cbs.h:73

cbs.h

av_buffer_ref

AVBufferRef * av_buffer_ref(const AVBufferRef *buf)

Create a new reference to an AVBuffer.

Definition: buffer.c:103

AV1_OBU_TEMPORAL_DELIMITER

@ AV1_OBU_TEMPORAL_DELIMITER

Definition: av1.h:31

AV1RawTileData::data

uint8_t * data

Definition: cbs_av1.h:290

AV1RawOBU::header

AV1RawOBUHeader header

Definition: cbs_av1.h:392

init_get_bits

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

Initialize GetBitContext.

Definition: get_bits.h:493

CodedBitstreamUnit

Coded bitstream unit structure.

Definition: cbs.h:69

AV1RawTileData

Definition: cbs_av1.h:289

cbs_av1_syntax_template.c

cbs_av1_read_subexp

static int cbs_av1_read_subexp(CodedBitstreamContext *ctx, GetBitContext *gbc, uint32_t range_max, const char *name, const int *subscripts, uint32_t *write_to)

Definition: cbs_av1.c:387

ff_cbs_write_unsigned

int ff_cbs_write_unsigned(CodedBitstreamContext *ctx, PutBitContext *pbc, int width, const char *name, const int *subscripts, uint32_t value, uint32_t range_min, uint32_t range_max)

Definition: cbs.c:586

get_bits

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

Read 1-25 bits.

Definition: get_bits.h:325

fail

#define fail()

Definition: checkasm.h:134

AV1_OBU_FRAME_HEADER

@ AV1_OBU_FRAME_HEADER

Definition: av1.h:32

CBS_UNIT_TYPE_INTERNAL_REF

#define CBS_UNIT_TYPE_INTERNAL_REF(type, structure, ref_field)

Definition: cbs_internal.h:219

GetBitContext

Definition: get_bits.h:107

CodedBitstreamAV1Context::ref

AV1ReferenceFrameState ref[AV1_NUM_REF_FRAMES]

Definition: cbs_av1.h:457

put_bits_left

static int put_bits_left(PutBitContext *s)

Definition: put_bits.h:125

cbs_av1_close

static void cbs_av1_close(CodedBitstreamContext *ctx)

Definition: cbs_av1.c:1292

ff_cbs_type_av1

const CodedBitstreamType ff_cbs_type_av1

Definition: cbs_av1.c:1351

CodedBitstreamUnit::data

uint8_t * data

Pointer to the directly-parsable bitstream form of this unit.

Definition: cbs.h:80

cbs_av1_write_obu

static int cbs_av1_write_obu(CodedBitstreamContext *ctx, CodedBitstreamUnit *unit, PutBitContext *pbc)

Definition: cbs_av1.c:1051

CodedBitstreamFragment::units

CodedBitstreamUnit * units

Pointer to an array of units of length nb_units_allocated.

Definition: cbs.h:167

cbs_av1.h

avassert.h

CodedBitstreamUnitTypeDescriptor

Definition: cbs_internal.h:55

AV1RawOBUHeader::obu_extension_flag

uint8_t obu_extension_flag

Definition: cbs_av1.h:32

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:180

cbs_av1_read_uvlc

static int cbs_av1_read_uvlc(CodedBitstreamContext *ctx, GetBitContext *gbc, const char *name, uint32_t *write_to, uint32_t range_min, uint32_t range_max)

Definition: cbs_av1.c:29

AV1RawOBU::tile_list

AV1RawTileList tile_list

Definition: cbs_av1.h:401

CodedBitstreamFragment

Coded bitstream fragment structure, combining one or more units.

Definition: cbs.h:121

cbs_av1_write_leb128

static int cbs_av1_write_leb128(CodedBitstreamContext *ctx, PutBitContext *pbc, const char *name, uint64_t value)

Definition: cbs_av1.c:180

CodedBitstreamFragment::data_size

size_t data_size

The number of bytes in the bitstream.

Definition: cbs.h:134

cbs_av1_ref_tile_data

static int cbs_av1_ref_tile_data(CodedBitstreamContext *ctx, CodedBitstreamUnit *unit, GetBitContext *gbc, AV1RawTileData *td)

Definition: cbs_av1.c:847

bits

uint8_t bits

Definition: vp3data.h:128

av_assert0

#define av_assert0(cond)

assert() equivalent, that is always enabled.

Definition: avassert.h:37

cbs_av1_split_fragment

static int cbs_av1_split_fragment(CodedBitstreamContext *ctx, CodedBitstreamFragment *frag, int header)

Definition: cbs_av1.c:738

ctx

AVFormatContext * ctx

Definition: movenc.c:48

cbs_av1_write_uvlc

static int cbs_av1_write_uvlc(CodedBitstreamContext *ctx, PutBitContext *pbc, const char *name, uint32_t value, uint32_t range_min, uint32_t range_max)

Definition: cbs_av1.c:107

ff_cbs_append_unit_data

int ff_cbs_append_unit_data(CodedBitstreamFragment *frag, CodedBitstreamUnitType type, uint8_t *data, size_t data_size, AVBufferRef *data_buf)

Add a new unit to a fragment with the given data bitstream.

Definition: cbs.c:813

CodedBitstreamAV1Context::operating_point_idc

int operating_point_idc

Definition: cbs_av1.h:440

cbs_internal.h

CodedBitstreamType::codec_id

enum AVCodecID codec_id

Definition: cbs_internal.h:102

AV1RawOBU::obu_size

size_t obu_size

Definition: cbs_av1.h:394

MAX_UINT_BITS

#define MAX_UINT_BITS(length)

Definition: cbs_internal.h:184

PutBitContext

Definition: put_bits.h:50

AV1RawOBU::obu

union AV1RawOBU::@27 obu

CodedBitstreamType::read_unit

int(* read_unit)(CodedBitstreamContext *ctx, CodedBitstreamUnit *unit)

Definition: cbs_internal.h:127

LIBAVUTIL_VERSION_INT

#define LIBAVUTIL_VERSION_INT

Definition: version.h:85

AV1RawMetadata

Definition: cbs_av1.h:373

AV1RawOBU

Definition: cbs_av1.h:391

AVClass

Describe the class of an AVClass context structure.

Definition: log.h:66

PutBitContext::buf

uint8_t * buf

Definition: put_bits.h:53

NULL

#define NULL

Definition: coverity.c:32

av_buffer_unref

void av_buffer_unref(AVBufferRef **buf)

Free a given reference and automatically free the buffer if there are no more references to it.

Definition: buffer.c:139

AV_CODEC_ID_AV1

@ AV_CODEC_ID_AV1

Definition: codec_id.h:283

cbs_av1_read_unit

static int cbs_av1_read_unit(CodedBitstreamContext *ctx, CodedBitstreamUnit *unit)

Definition: cbs_av1.c:873

cbs_av1_get_payload_bytes_left

static size_t cbs_av1_get_payload_bytes_left(GetBitContext *gbc)

Definition: cbs_av1.c:521

cbs_av1_options

static const AVOption cbs_av1_options[]

Definition: cbs_av1.c:1338

av_default_item_name

const char * av_default_item_name(void *ptr)

Return the context name.

Definition: log.c:237

get_bits1

static unsigned int get_bits1(GetBitContext *s)

Definition: get_bits.h:378

CodedBitstreamUnit::data_size

size_t data_size

The number of bytes in the bitstream (including any padding bits in the final byte).

Definition: cbs.h:85

cbs_av1_write_subexp

static int cbs_av1_write_subexp(CodedBitstreamContext *ctx, PutBitContext *pbc, uint32_t range_max, const char *name, const int *subscripts, uint32_t value)

Definition: cbs_av1.c:437

AV1_OBU_TILE_GROUP

@ AV1_OBU_TILE_GROUP

Definition: av1.h:33

AV1_OBU_FRAME

@ AV1_OBU_FRAME

Definition: av1.h:35

AV1RawTileList::tile_data

AV1RawTileData tile_data

Definition: cbs_av1.h:313

cbs_av1_flush

static void cbs_av1_flush(CodedBitstreamContext *ctx)

Definition: cbs_av1.c:1278

byte

uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_WB32 unsigned int_TMPL AV_WB24 unsigned int_TMPL AV_WB16 unsigned int_TMPL byte

Definition: bytestream.h:99

size

int size

Definition: twinvq_data.h:10344

AV1RawOBU::sequence_header

AV1RawSequenceHeader sequence_header

Definition: cbs_av1.h:397

CodedBitstreamFragment::data

uint8_t * data

Pointer to the bitstream form of this fragment.

Definition: cbs.h:127

CodedBitstreamAV1Context::frame_header

uint8_t * frame_header

Definition: cbs_av1.h:435

OFFSET

#define OFFSET(x)

Definition: cbs_av1.c:1337

AV1_OBU_SEQUENCE_HEADER

@ AV1_OBU_SEQUENCE_HEADER

Definition: av1.h:30

CodedBitstreamType::unit_types

const CodedBitstreamUnitTypeDescriptor * unit_types

Definition: cbs_internal.h:114

header

static const uint8_t header[24]

Definition: sdr2.c:67

diff

static av_always_inline int diff(const struct color_info *a, const struct color_info *b, const int trans_thresh)

Definition: vf_paletteuse.c:162

The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a

Definition: undefined.txt:41

CodedBitstreamAV1Context::sequence_header_ref

AVBufferRef * sequence_header_ref

Definition: cbs_av1.h:431

CBS_UNIT_TYPE_POD

#define CBS_UNIT_TYPE_POD(type_, structure)

Definition: cbs_internal.h:195

CodedBitstreamType

Definition: cbs_internal.h:101

av_buffer_alloc

AVBufferRef * av_buffer_alloc(size_t size)

Allocate an AVBuffer of the given size using av_malloc().

Definition: buffer.c:77

AV1RawOBU::frame_header

AV1RawFrameHeader frame_header

Definition: cbs_av1.h:398

ff_cbs_trace_syntax_element

void ff_cbs_trace_syntax_element(CodedBitstreamContext *ctx, int position, const char *str, const int *subscripts, const char *bits, int64_t value)

Definition: cbs.c:493

cbs_av1_assemble_fragment

static int cbs_av1_assemble_fragment(CodedBitstreamContext *ctx, CodedBitstreamFragment *frag)

Definition: cbs_av1.c:1250

AV1RawOBU::metadata

AV1RawMetadata metadata

Definition: cbs_av1.h:402

cbs_av1_tile_log2

static int cbs_av1_tile_log2(int blksize, int target)

Definition: cbs_av1.c:502

CodedBitstreamAV1Context::spatial_id

int spatial_id

Definition: cbs_av1.h:439

AV1_OBU_PADDING

@ AV1_OBU_PADDING

Definition: av1.h:39

CodedBitstreamUnit::data_ref

AVBufferRef * data_ref

A reference to the buffer containing data.

Definition: cbs.h:97

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

Definition: cbs_h2645.c:269

CodedBitstreamType::write_unit

int(* write_unit)(CodedBitstreamContext *ctx, CodedBitstreamUnit *unit, PutBitContext *pbc)

Definition: cbs_internal.h:132

put_bits_count

static int put_bits_count(PutBitContext *s)

Definition: put_bits.h:80

value

it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default value

Definition: writing_filters.txt:86

FFMIN

#define FFMIN(a, b)

Definition: macros.h:49

len

int len

Definition: vorbis_enc_data.h:426

ff_cbs_make_unit_refcounted

int ff_cbs_make_unit_refcounted(CodedBitstreamContext *ctx, CodedBitstreamUnit *unit)

Make the content of a unit refcounted.

Definition: cbs.c:1004

AV1RawSequenceHeader::enable_order_hint

uint8_t enable_order_hint

Definition: cbs_av1.h:113

ff_cbs_read_unsigned

int ff_cbs_read_unsigned(CodedBitstreamContext *ctx, GetBitContext *gbc, int width, const char *name, const int *subscripts, uint32_t *write_to, uint32_t range_min, uint32_t range_max)

Definition: cbs.c:543

AV1RawOBU::tile_group

AV1RawTileGroup tile_group

Definition: cbs_av1.h:400

avcodec.h

AV1RawTileGroup::tile_data

AV1RawTileData tile_data

Definition: cbs_av1.h:300

CBS_UNIT_TYPE_END_OF_LIST

#define CBS_UNIT_TYPE_END_OF_LIST

Definition: cbs_internal.h:242

CodedBitstreamUnit::content_ref