FFmpeg: libavcodec/h2645_parse.c Source File

FFmpeg

[フレーム]

libavcodec

h2645_parse.c

Go to the documentation of this file.

1 /*

2 * H.264/HEVC 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 #include <string.h>

23 #include "config.h"

25 #include "libavutil/intmath.h"

26 #include "libavutil/intreadwrite.h"

27 #include "libavutil/mem.h"

29 #include "bytestream.h"

30 #include "hevc.h"

31 #include "h264.h"

32 #include "h2645_parse.h"

33 #include "vvc.h"

35 int ff_h2645_extract_rbsp(const uint8_t *src, int length,

36 H2645RBSP *rbsp, H2645NAL *nal, int small_padding)

37 {

38 int i, si, di;

39 uint8_t *dst;

41 nal->skipped_bytes = 0;

42 #define STARTCODE_TEST \

43 if (i + 2 < length && src[i + 1] == 0 && \

44 (src[i + 2] == 3 || src[i + 2] == 1)) { \

45 if (src[i + 2] == 1) { \

46 /* startcode, so we must be past the end */ \

47 length = i; \

48 } \

49 break; \

50 }

51 #if HAVE_FAST_UNALIGNED

52 #define FIND_FIRST_ZERO \

53 if (i > 0 && !src[i]) \

54 i--; \

55 while (src[i]) \

56 i++

57 #if HAVE_FAST_64BIT

58 for (i = 0; i + 1 < length; i += 9) {

59 if (!((~AV_RN64(src + i) &

60 (AV_RN64(src + i) - 0x0100010001000101ULL)) &

61 0x8000800080008080ULL))

62 continue;

63 FIND_FIRST_ZERO;

64 STARTCODE_TEST;

65 i -= 7;

66 }

67 #else

68 for (i = 0; i + 1 < length; i += 5) {

69 if (!((~AV_RN32(src + i) &

70 (AV_RN32(src + i) - 0x01000101U)) &

71 0x80008080U))

72 continue;

73 FIND_FIRST_ZERO;

74 STARTCODE_TEST;

75 i -= 3;

76 }

77 #endif /* HAVE_FAST_64BIT */

78 #else

79 for (i = 0; i + 1 < length; i += 2) {

80 if (src[i])

81 continue;

82 if (i > 0 && src[i - 1] == 0)

83 i--;

84 STARTCODE_TEST;

85 }

86 #endif /* HAVE_FAST_UNALIGNED */

88 if (i >= length - 1 && small_padding) { // no escaped 0

89 nal->data =

90 nal->raw_data = src;

91 nal->size =

92 nal->raw_size = length;

93 return length;

94 } else if (i > length)

95 i = length;

97 dst = &rbsp->rbsp_buffer[rbsp->rbsp_buffer_size];

99 memcpy(dst, src, i);

100 si = di = i;

101 while (si + 2 < length) {

102 // remove escapes (very rare 1:2^22)

103 if (src[si + 2] > 3) {

104 dst[di++] = src[si++];

105 dst[di++] = src[si++];

106 } else if (src[si] == 0 && src[si + 1] == 0 && src[si + 2] != 0) {

107 if (src[si + 2] == 3) { // escape

108 dst[di++] = 0;

109 dst[di++] = 0;

110 si += 3;

111

112 if (nal->skipped_bytes_pos) {

113 nal->skipped_bytes++;

114 if (nal->skipped_bytes_pos_size < nal->skipped_bytes) {

115 nal->skipped_bytes_pos_size *= 2;

116 av_assert0(nal->skipped_bytes_pos_size >= nal->skipped_bytes);

117 av_reallocp_array(&nal->skipped_bytes_pos,

118 nal->skipped_bytes_pos_size,

119 sizeof(*nal->skipped_bytes_pos));

120 if (!nal->skipped_bytes_pos) {

121 nal->skipped_bytes_pos_size = 0;

122 return AVERROR(ENOMEM);

123 }

124 }

125 if (nal->skipped_bytes_pos)

126 nal->skipped_bytes_pos[nal->skipped_bytes-1] = di - 1;

127 }

128 continue;

129 } else // next start code

130 goto nsc;

131 }

132

133 dst[di++] = src[si++];

134 }

135 while (si < length)

136 dst[di++] = src[si++];

137

138 nsc:

139 memset(dst + di, 0, AV_INPUT_BUFFER_PADDING_SIZE);

140

141 nal->data = dst;

142 nal->size = di;

143 nal->raw_data = src;

144 nal->raw_size = si;

145 rbsp->rbsp_buffer_size += si;

146

147 return si;

148 }

149

150 static const char *const vvc_nal_type_name[32] = {

151 "TRAIL_NUT", // VVC_TRAIL_NUT

152 "STSA_NUT", // VVC_STSA_NUT

153 "RADL_NUT", // VVC_RADL_NUT

154 "RASL_NUT", // VVC_RASL_NUT

155 "RSV_VCL4", // VVC_RSV_VCL_4

156 "RSV_VCL5", // VVC_RSV_VCL_5

157 "RSV_VCL6", // VVC_RSV_VCL_6

158 "IDR_W_RADL", // VVC_IDR_W_RADL

159 "IDR_N_LP", // VVC_IDR_N_LP

160 "CRA_NUT", // VVC_CRA_NUT

161 "GDR_NUT", // VVC_GDR_NUT

162 "RSV_IRAP_11", // VVC_RSV_IRAP_11

163 "OPI_NUT", // VVC_OPI_NUT

164 "DCI_NUT", // VVC_DCI_NUT

165 "VPS_NUT", // VVC_VPS_NUT

166 "SPS_NUT", // VVC_SPS_NUT

167 "PPS_NUT", // VVC_PPS_NUT

168 "APS_PREFIX", // VVC_PREFIX_APS_NUT

169 "APS_SUFFIX", // VVC_SUFFIX_APS_NUT

170 "PH_NUT", // VVC_PH_NUT

171 "AUD_NUT", // VVC_AUD_NUT

172 "EOS_NUT", // VVC_EOS_NUT

173 "EOB_NUT", // VVC_EOB_NUT

174 "SEI_PREFIX", // VVC_PREFIX_SEI_NUT

175 "SEI_SUFFIX", // VVC_SUFFIX_SEI_NUT

176 "FD_NUT", // VVC_FD_NUT

177 "RSV_NVCL26", // VVC_RSV_NVCL_26

178 "RSV_NVCL27", // VVC_RSV_NVCL_27

179 "UNSPEC28", // VVC_UNSPEC_28

180 "UNSPEC29", // VVC_UNSPEC_29

181 "UNSPEC30", // VVC_UNSPEC_30

182 "UNSPEC31", // VVC_UNSPEC_31

183 };

184

185 static const char *vvc_nal_unit_name(int nal_type)

186 {

187 av_assert0(nal_type >= 0 && nal_type < 32);

188 return vvc_nal_type_name[nal_type];

189 }

190

191 static const char *const hevc_nal_type_name[64] = {

192 "TRAIL_N", // HEVC_NAL_TRAIL_N

193 "TRAIL_R", // HEVC_NAL_TRAIL_R

194 "TSA_N", // HEVC_NAL_TSA_N

195 "TSA_R", // HEVC_NAL_TSA_R

196 "STSA_N", // HEVC_NAL_STSA_N

197 "STSA_R", // HEVC_NAL_STSA_R

198 "RADL_N", // HEVC_NAL_RADL_N

199 "RADL_R", // HEVC_NAL_RADL_R

200 "RASL_N", // HEVC_NAL_RASL_N

201 "RASL_R", // HEVC_NAL_RASL_R

202 "RSV_VCL_N10", // HEVC_NAL_VCL_N10

203 "RSV_VCL_R11", // HEVC_NAL_VCL_R11

204 "RSV_VCL_N12", // HEVC_NAL_VCL_N12

205 "RSV_VLC_R13", // HEVC_NAL_VCL_R13

206 "RSV_VCL_N14", // HEVC_NAL_VCL_N14

207 "RSV_VCL_R15", // HEVC_NAL_VCL_R15

208 "BLA_W_LP", // HEVC_NAL_BLA_W_LP

209 "BLA_W_RADL", // HEVC_NAL_BLA_W_RADL

210 "BLA_N_LP", // HEVC_NAL_BLA_N_LP

211 "IDR_W_RADL", // HEVC_NAL_IDR_W_RADL

212 "IDR_N_LP", // HEVC_NAL_IDR_N_LP

213 "CRA_NUT", // HEVC_NAL_CRA_NUT

214 "RSV_IRAP_VCL22", // HEVC_NAL_RSV_IRAP_VCL22

215 "RSV_IRAP_VCL23", // HEVC_NAL_RSV_IRAP_VCL23

216 "RSV_VCL24", // HEVC_NAL_RSV_VCL24

217 "RSV_VCL25", // HEVC_NAL_RSV_VCL25

218 "RSV_VCL26", // HEVC_NAL_RSV_VCL26

219 "RSV_VCL27", // HEVC_NAL_RSV_VCL27

220 "RSV_VCL28", // HEVC_NAL_RSV_VCL28

221 "RSV_VCL29", // HEVC_NAL_RSV_VCL29

222 "RSV_VCL30", // HEVC_NAL_RSV_VCL30

223 "RSV_VCL31", // HEVC_NAL_RSV_VCL31

224 "VPS", // HEVC_NAL_VPS

225 "SPS", // HEVC_NAL_SPS

226 "PPS", // HEVC_NAL_PPS

227 "AUD", // HEVC_NAL_AUD

228 "EOS_NUT", // HEVC_NAL_EOS_NUT

229 "EOB_NUT", // HEVC_NAL_EOB_NUT

230 "FD_NUT", // HEVC_NAL_FD_NUT

231 "SEI_PREFIX", // HEVC_NAL_SEI_PREFIX

232 "SEI_SUFFIX", // HEVC_NAL_SEI_SUFFIX

233 "RSV_NVCL41", // HEVC_NAL_RSV_NVCL41

234 "RSV_NVCL42", // HEVC_NAL_RSV_NVCL42

235 "RSV_NVCL43", // HEVC_NAL_RSV_NVCL43

236 "RSV_NVCL44", // HEVC_NAL_RSV_NVCL44

237 "RSV_NVCL45", // HEVC_NAL_RSV_NVCL45

238 "RSV_NVCL46", // HEVC_NAL_RSV_NVCL46

239 "RSV_NVCL47", // HEVC_NAL_RSV_NVCL47

240 "UNSPEC48", // HEVC_NAL_UNSPEC48

241 "UNSPEC49", // HEVC_NAL_UNSPEC49

242 "UNSPEC50", // HEVC_NAL_UNSPEC50

243 "UNSPEC51", // HEVC_NAL_UNSPEC51

244 "UNSPEC52", // HEVC_NAL_UNSPEC52

245 "UNSPEC53", // HEVC_NAL_UNSPEC53

246 "UNSPEC54", // HEVC_NAL_UNSPEC54

247 "UNSPEC55", // HEVC_NAL_UNSPEC55

248 "UNSPEC56", // HEVC_NAL_UNSPEC56

249 "UNSPEC57", // HEVC_NAL_UNSPEC57

250 "UNSPEC58", // HEVC_NAL_UNSPEC58

251 "UNSPEC59", // HEVC_NAL_UNSPEC59

252 "UNSPEC60", // HEVC_NAL_UNSPEC60

253 "UNSPEC61", // HEVC_NAL_UNSPEC61

254 "UNSPEC62", // HEVC_NAL_UNSPEC62

255 "UNSPEC63", // HEVC_NAL_UNSPEC63

256 };

257

258 static const char *hevc_nal_unit_name(int nal_type)

259 {

260 av_assert0(nal_type >= 0 && nal_type < 64);

261 return hevc_nal_type_name[nal_type];

262 }

263

264 static const char *const h264_nal_type_name[32] = {

265 "Unspecified 0", //H264_NAL_UNSPECIFIED

266 "Coded slice of a non-IDR picture", // H264_NAL_SLICE

267 "Coded slice data partition A", // H264_NAL_DPA

268 "Coded slice data partition B", // H264_NAL_DPB

269 "Coded slice data partition C", // H264_NAL_DPC

270 "IDR", // H264_NAL_IDR_SLICE

271 "SEI", // H264_NAL_SEI

272 "SPS", // H264_NAL_SPS

273 "PPS", // H264_NAL_PPS

274 "AUD", // H264_NAL_AUD

275 "End of sequence", // H264_NAL_END_SEQUENCE

276 "End of stream", // H264_NAL_END_STREAM

277 "Filler data", // H264_NAL_FILLER_DATA

278 "SPS extension", // H264_NAL_SPS_EXT

279 "Prefix", // H264_NAL_PREFIX

280 "Subset SPS", // H264_NAL_SUB_SPS

281 "Depth parameter set", // H264_NAL_DPS

282 "Reserved 17", // H264_NAL_RESERVED17

283 "Reserved 18", // H264_NAL_RESERVED18

284 "Auxiliary coded picture without partitioning", // H264_NAL_AUXILIARY_SLICE

285 "Slice extension", // H264_NAL_EXTEN_SLICE

286 "Slice extension for a depth view or a 3D-AVC texture view", // H264_NAL_DEPTH_EXTEN_SLICE

287 "Reserved 22", // H264_NAL_RESERVED22

288 "Reserved 23", // H264_NAL_RESERVED23

289 "Unspecified 24", // H264_NAL_UNSPECIFIED24

290 "Unspecified 25", // H264_NAL_UNSPECIFIED25

291 "Unspecified 26", // H264_NAL_UNSPECIFIED26

292 "Unspecified 27", // H264_NAL_UNSPECIFIED27

293 "Unspecified 28", // H264_NAL_UNSPECIFIED28

294 "Unspecified 29", // H264_NAL_UNSPECIFIED29

295 "Unspecified 30", // H264_NAL_UNSPECIFIED30

296 "Unspecified 31", // H264_NAL_UNSPECIFIED31

297 };

298

299 static const char *h264_nal_unit_name(int nal_type)

300 {

301 av_assert0(nal_type >= 0 && nal_type < 32);

302 return h264_nal_type_name[nal_type];

303 }

304

305 static int get_bit_length(H2645NAL *nal, int min_size, int skip_trailing_zeros)

306 {

307 int size = nal->size;

308 int trailing_padding = 0;

309

310 while (skip_trailing_zeros && size > 0 && nal->data[size - 1] == 0)

311 size--;

312

313 if (!size)

314 return 0;

315

316 if (size <= min_size) {

317 if (nal->size < min_size)

318 return AVERROR_INVALIDDATA;

319 size = min_size;

320 } else {

321 int v = nal->data[size - 1];

322 /* remove the stop bit and following trailing zeros,

323 * or nothing for damaged bitstreams */

324 if (v)

325 trailing_padding = ff_ctz(v) + 1;

326 }

327

328 if (size > INT_MAX / 8)

329 return AVERROR(ERANGE);

330 size *= 8;

331

332 return size - trailing_padding;

333 }

334

335 /**

336 * @return AVERROR_INVALIDDATA if the packet is not a valid NAL unit,

337 * 0 otherwise

338 */

339 static int vvc_parse_nal_header(H2645NAL *nal, void *logctx)

340 {

341 GetBitContext *gb = &nal->gb;

342

343 if (get_bits1(gb) != 0) //forbidden_zero_bit

344 return AVERROR_INVALIDDATA;

345

346 skip_bits1(gb); //nuh_reserved_zero_bit

347

348 nal->nuh_layer_id = get_bits(gb, 6);

349 nal->type = get_bits(gb, 5);

350 nal->temporal_id = get_bits(gb, 3) - 1;

351 if (nal->temporal_id < 0)

352 return AVERROR_INVALIDDATA;

353

354 if ((nal->type >= VVC_IDR_W_RADL && nal->type <= VVC_RSV_IRAP_11) && nal->temporal_id)

355 return AVERROR_INVALIDDATA;

356

357 av_log(logctx, AV_LOG_DEBUG,

358 "nal_unit_type: %d(%s), nuh_layer_id: %d, temporal_id: %d\n",

359 nal->type, vvc_nal_unit_name(nal->type), nal->nuh_layer_id, nal->temporal_id);

360

361 return 0;

362 }

363

364 static int hevc_parse_nal_header(H2645NAL *nal, void *logctx)

365 {

366 GetBitContext *gb = &nal->gb;

367

368 if (get_bits1(gb) != 0)

369 return AVERROR_INVALIDDATA;

370

371 nal->type = get_bits(gb, 6);

372

373 nal->nuh_layer_id = get_bits(gb, 6);

374 nal->temporal_id = get_bits(gb, 3) - 1;

375 if (nal->temporal_id < 0)

376 return AVERROR_INVALIDDATA;

377

378 av_log(logctx, AV_LOG_DEBUG,

379 "nal_unit_type: %d(%s), nuh_layer_id: %d, temporal_id: %d\n",

380 nal->type, hevc_nal_unit_name(nal->type), nal->nuh_layer_id, nal->temporal_id);

381

382 return 0;

383 }

384

385 static int h264_parse_nal_header(H2645NAL *nal, void *logctx)

386 {

387 GetBitContext *gb = &nal->gb;

388

389 if (get_bits1(gb) != 0)

390 return AVERROR_INVALIDDATA;

391

392 nal->ref_idc = get_bits(gb, 2);

393 nal->type = get_bits(gb, 5);

394

395 av_log(logctx, AV_LOG_DEBUG,

396 "nal_unit_type: %d(%s), nal_ref_idc: %d\n",

397 nal->type, h264_nal_unit_name(nal->type), nal->ref_idc);

398

399 return 0;

400 }

401

402 static int find_next_start_code(const uint8_t *buf, const uint8_t *next_avc)

403 {

404 int i = 0;

405

406 if (buf + 3 >= next_avc)

407 return next_avc - buf;

408

409 while (buf + i + 3 < next_avc) {

410 if (buf[i] == 0 && buf[i + 1] == 0 && buf[i + 2] == 1)

411 break;

412 i++;

413 }

414 return i + 3;

415 }

416

417 static void alloc_rbsp_buffer(H2645RBSP *rbsp, unsigned int size, int use_ref)

418 {

419 int min_size = size;

420

421 if (size > INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE)

422 goto fail;

423 size += AV_INPUT_BUFFER_PADDING_SIZE;

424

425 if (rbsp->rbsp_buffer_alloc_size >= size &&

426 (!rbsp->rbsp_buffer_ref || av_buffer_is_writable(rbsp->rbsp_buffer_ref))) {

427 av_assert0(rbsp->rbsp_buffer);

428 memset(rbsp->rbsp_buffer + min_size, 0, AV_INPUT_BUFFER_PADDING_SIZE);

429 return;

430 }

431

432 size = FFMIN(size + size / 16 + 32, INT_MAX);

433

434 if (rbsp->rbsp_buffer_ref)

435 av_buffer_unref(&rbsp->rbsp_buffer_ref);

436 else

437 av_free(rbsp->rbsp_buffer);

438

439 rbsp->rbsp_buffer = av_mallocz(size);

440 if (!rbsp->rbsp_buffer)

441 goto fail;

442 rbsp->rbsp_buffer_alloc_size = size;

443

444 if (use_ref) {

445 rbsp->rbsp_buffer_ref = av_buffer_create(rbsp->rbsp_buffer, size,

446 NULL, NULL, 0);

447 if (!rbsp->rbsp_buffer_ref)

448 goto fail;

449 }

450

451 return;

452

453 fail:

454 rbsp->rbsp_buffer_alloc_size = 0;

455 if (rbsp->rbsp_buffer_ref) {

456 av_buffer_unref(&rbsp->rbsp_buffer_ref);

457 rbsp->rbsp_buffer = NULL;

458 } else

459 av_freep(&rbsp->rbsp_buffer);

460

461 return;

462 }

463

464 int ff_h2645_packet_split(H2645Packet *pkt, const uint8_t *buf, int length,

465 void *logctx, int is_nalff, int nal_length_size,

466 enum AVCodecID codec_id, int small_padding, int use_ref)

467 {

468 GetByteContext bc;

469 int consumed, ret = 0;

470 int next_avc = is_nalff ? 0 : length;

471 int64_t padding = small_padding ? 0 : MAX_MBPAIR_SIZE;

472

473 bytestream2_init(&bc, buf, length);

474 alloc_rbsp_buffer(&pkt->rbsp, length + padding, use_ref);

475

476 if (!pkt->rbsp.rbsp_buffer)

477 return AVERROR(ENOMEM);

478

479 pkt->rbsp.rbsp_buffer_size = 0;

480 pkt->nb_nals = 0;

481 while (bytestream2_get_bytes_left(&bc) >= 4) {

482 H2645NAL *nal;

483 int extract_length = 0;

484 int skip_trailing_zeros = 1;

485

486 if (bytestream2_tell(&bc) == next_avc) {

487 int i = 0;

488 extract_length = get_nalsize(nal_length_size,

489 bc.buffer, bytestream2_get_bytes_left(&bc), &i, logctx);

490 if (extract_length < 0)

491 return extract_length;

492

493 bytestream2_skip(&bc, nal_length_size);

494

495 next_avc = bytestream2_tell(&bc) + extract_length;

496 } else {

497 int buf_index;

498

499 if (bytestream2_tell(&bc) > next_avc)

500 av_log(logctx, AV_LOG_WARNING, "Exceeded next NALFF position, re-syncing.\n");

501

502 /* search start code */

503 buf_index = find_next_start_code(bc.buffer, buf + next_avc);

504

505 bytestream2_skip(&bc, buf_index);

506

507 if (!bytestream2_get_bytes_left(&bc)) {

508 if (pkt->nb_nals > 0) {

509 // No more start codes: we discarded some irrelevant

510 // bytes at the end of the packet.

511 return 0;

512 } else {

513 av_log(logctx, AV_LOG_ERROR, "No start code is found.\n");

514 return AVERROR_INVALIDDATA;

515 }

516 }

517

518 extract_length = FFMIN(bytestream2_get_bytes_left(&bc), next_avc - bytestream2_tell(&bc));

519

520 if (bytestream2_tell(&bc) >= next_avc) {

521 /* skip to the start of the next NAL */

522 bytestream2_skip(&bc, next_avc - bytestream2_tell(&bc));

523 continue;

524 }

525 }

526

527 if (pkt->nals_allocated < pkt->nb_nals + 1) {

528 int new_size = pkt->nals_allocated + 1;

529 void *tmp;

530

531 if (new_size >= INT_MAX / sizeof(*pkt->nals))

532 return AVERROR(ENOMEM);

533

534 tmp = av_fast_realloc(pkt->nals, &pkt->nal_buffer_size, new_size * sizeof(*pkt->nals));

535 if (!tmp)

536 return AVERROR(ENOMEM);

537

538 pkt->nals = tmp;

539 memset(pkt->nals + pkt->nals_allocated, 0, sizeof(*pkt->nals));

540

541 nal = &pkt->nals[pkt->nb_nals];

542 nal->skipped_bytes_pos_size = FFMIN(1024, extract_length/3+1); // initial buffer size

543 nal->skipped_bytes_pos = av_malloc_array(nal->skipped_bytes_pos_size, sizeof(*nal->skipped_bytes_pos));

544 if (!nal->skipped_bytes_pos)

545 return AVERROR(ENOMEM);

546

547 pkt->nals_allocated = new_size;

548 }

549 nal = &pkt->nals[pkt->nb_nals];

550

551 consumed = ff_h2645_extract_rbsp(bc.buffer, extract_length, &pkt->rbsp, nal, small_padding);

552 if (consumed < 0)

553 return consumed;

554

555 if (is_nalff && (extract_length != consumed) && extract_length)

556 av_log(logctx, AV_LOG_DEBUG,

557 "NALFF: Consumed only %d bytes instead of %d\n",

558 consumed, extract_length);

559

560 bytestream2_skip(&bc, consumed);

561

562 /* see commit 3566042a0 */

563 if (bytestream2_get_bytes_left(&bc) >= 4 &&

564 bytestream2_peek_be32(&bc) == 0x000001E0)

565 skip_trailing_zeros = 0;

566

567 nal->size_bits = get_bit_length(nal, 1 + (codec_id == AV_CODEC_ID_HEVC),

568 skip_trailing_zeros);

569

570 if (nal->size <= 0 || nal->size_bits <= 0)

571 continue;

572

573 ret = init_get_bits(&nal->gb, nal->data, nal->size_bits);

574 if (ret < 0)

575 return ret;

576

577 /* Reset type in case it contains a stale value from a previously parsed NAL */

578 nal->type = 0;

579

580 if (codec_id == AV_CODEC_ID_VVC)

581 ret = vvc_parse_nal_header(nal, logctx);

582 else if (codec_id == AV_CODEC_ID_HEVC)

583 ret = hevc_parse_nal_header(nal, logctx);

584 else

585 ret = h264_parse_nal_header(nal, logctx);

586 if (ret < 0) {

587 av_log(logctx, AV_LOG_WARNING, "Invalid NAL unit %d, skipping.\n",

588 nal->type);

589 continue;

590 }

591

592 pkt->nb_nals++;

593 }

594

595 return 0;

596 }

597

598 void ff_h2645_packet_uninit(H2645Packet *pkt)

599 {

600 int i;

601 for (i = 0; i < pkt->nals_allocated; i++) {

602 av_freep(&pkt->nals[i].skipped_bytes_pos);

603 }

604 av_freep(&pkt->nals);

605 pkt->nals_allocated = pkt->nal_buffer_size = 0;

606 if (pkt->rbsp.rbsp_buffer_ref) {

607 av_buffer_unref(&pkt->rbsp.rbsp_buffer_ref);

608 pkt->rbsp.rbsp_buffer = NULL;

609 } else

610 av_freep(&pkt->rbsp.rbsp_buffer);

611 pkt->rbsp.rbsp_buffer_alloc_size = pkt->rbsp.rbsp_buffer_size = 0;

612 }

AV_LOG_WARNING

#define AV_LOG_WARNING

Something somehow does not look correct.

Definition: log.h:186

h2645_parse.h

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

ff_ctz

#define ff_ctz

Definition: intmath.h:107

STARTCODE_TEST

#define STARTCODE_TEST

GetByteContext

Definition: bytestream.h:33

get_bit_length

static int get_bit_length(H2645NAL *nal, int min_size, int skip_trailing_zeros)

Definition: h2645_parse.c:305

int64_t

long long int64_t

Definition: coverity.c:34

H2645NAL::ref_idc

int ref_idc

H.264 only, nal_ref_idc.

Definition: h2645_parse.h:57

H2645NAL::nuh_layer_id

int nuh_layer_id

Definition: h2645_parse.h:67

AV_RN64

#define AV_RN64(p)

Definition: intreadwrite.h:366

tmp

static uint8_t tmp[11]

Definition: aes_ctr.c:28

h264_parse_nal_header

static int h264_parse_nal_header(H2645NAL *nal, void *logctx)

Definition: h2645_parse.c:385

ff_h2645_packet_uninit

void ff_h2645_packet_uninit(H2645Packet *pkt)

Free all the allocated memory in the packet.

Definition: h2645_parse.c:598

find_next_start_code

static int find_next_start_code(const uint8_t *buf, const uint8_t *next_avc)

Definition: h2645_parse.c:402

H2645NAL::skipped_bytes_pos_size

int skipped_bytes_pos_size

Definition: h2645_parse.h:70

H2645NAL::temporal_id

int temporal_id

HEVC only, nuh_temporal_id_plus_1 - 1.

Definition: h2645_parse.h:62

init_get_bits

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

Initialize GetBitContext.

Definition: get_bits.h:514

hevc_parse_nal_header

static int hevc_parse_nal_header(H2645NAL *nal, void *logctx)

Definition: h2645_parse.c:364

H2645NAL::size_bits

int size_bits

Size, in bits, of just the data, excluding the stop bit and any trailing padding.

Definition: h2645_parse.h:42

bytestream2_skip

static av_always_inline void bytestream2_skip(GetByteContext *g, unsigned int size)

Definition: bytestream.h:168

get_bits

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

Read 1-25 bits.

Definition: get_bits.h:335

hevc_nal_unit_name

static const char * hevc_nal_unit_name(int nal_type)

Definition: h2645_parse.c:258

fail

#define fail()

Definition: checkasm.h:179

GetBitContext

Definition: get_bits.h:108

VVC_IDR_W_RADL

@ VVC_IDR_W_RADL

Definition: vvc.h:36

pkt

AVPacket * pkt

Definition: movenc.c:59

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:180

H2645NAL::size

int size

Definition: h2645_parse.h:36

h264_nal_type_name

static const char *const h264_nal_type_name[32]

Definition: h2645_parse.c:264

av_fast_realloc

void * av_fast_realloc(void *ptr, unsigned int *size, size_t min_size)

Reallocate the given buffer if it is not large enough, otherwise do nothing.

Definition: mem.c:495

intreadwrite.h

GetByteContext::buffer

const uint8_t * buffer

Definition: bytestream.h:34

av_assert0

#define av_assert0(cond)

assert() equivalent, that is always enabled.

Definition: avassert.h:40

AV_LOG_DEBUG

#define AV_LOG_DEBUG

Stuff which is only useful for libav* developers.

Definition: log.h:201

H2645NAL::data

const uint8_t * data

Definition: h2645_parse.h:35

H2645NAL::skipped_bytes_pos

int * skipped_bytes_pos

Definition: h2645_parse.h:71

codec_id

enum AVCodecID codec_id

Definition: vaapi_decode.c:387

H2645NAL::type

int type

NAL unit type.

Definition: h2645_parse.h:52

H2645NAL::raw_size

int raw_size

Definition: h2645_parse.h:44

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

get_bits1

static unsigned int get_bits1(GetBitContext *s)

Definition: get_bits.h:388

AV_RN32

#define AV_RN32(p)

Definition: intreadwrite.h:362

av_buffer_create

AVBufferRef * av_buffer_create(uint8_t *data, size_t size, void(*free)(void *opaque, uint8_t *data), void *opaque, int flags)

Create an AVBuffer from an existing array.

Definition: buffer.c:55

bytestream2_get_bytes_left

static av_always_inline int bytestream2_get_bytes_left(GetByteContext *g)

Definition: bytestream.h:158

AVCodecID

Identify the syntax and semantics of the bitstream.

Definition: codec_id.h:49

bytestream2_tell

static av_always_inline int bytestream2_tell(GetByteContext *g)

Definition: bytestream.h:192

H2645NAL::skipped_bytes

int skipped_bytes

Definition: h2645_parse.h:69

H2645RBSP::rbsp_buffer

uint8_t * rbsp_buffer

Definition: h2645_parse.h:75

hevc_nal_type_name

static const char *const hevc_nal_type_name[64]

Definition: h2645_parse.c:191

vvc_nal_type_name

static const char *const vvc_nal_type_name[32]

Definition: h2645_parse.c:150

size

int size

Definition: twinvq_data.h:10344

H2645NAL::gb

GetBitContext gb

Definition: h2645_parse.h:47

vvc_nal_unit_name

static const char * vvc_nal_unit_name(int nal_type)

Definition: h2645_parse.c:185

H2645NAL

Definition: h2645_parse.h:34

H2645RBSP::rbsp_buffer_size

int rbsp_buffer_size

Definition: h2645_parse.h:78

ff_h2645_packet_split

int ff_h2645_packet_split(H2645Packet *pkt, const uint8_t *buf, int length, void *logctx, int is_nalff, int nal_length_size, enum AVCodecID codec_id, int small_padding, int use_ref)

Split an input packet into NAL units.

Definition: h2645_parse.c:464

av_reallocp_array

int av_reallocp_array(void *ptr, size_t nmemb, size_t size)

Allocate, reallocate an array through a pointer to a pointer.

Definition: mem.c:223

AV_CODEC_ID_VVC

@ AV_CODEC_ID_VVC

Definition: codec_id.h:250

skip_bits1

static void skip_bits1(GetBitContext *s)

Definition: get_bits.h:413