FFmpeg: libavformat/avc.c Source File

FFmpeg

[フレーム]

libavformat

avc.c

Go to the documentation of this file.

1 /*

2 * AVC helper functions for muxers

4 *

5 * This file is part of FFmpeg.

6 *

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

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

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

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

11 *

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

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

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

15 * Lesser General Public License for more details.

16 *

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

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

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

20 */

22 #include "libavutil/intreadwrite.h"

23 #include "libavcodec/h264.h"

24 #include "libavcodec/get_bits.h"

25 #include "avformat.h"

26 #include "avio.h"

27 #include "avc.h"

28 #include "avio_internal.h"

30 static const uint8_t *avc_find_startcode_internal(const uint8_t *p, const uint8_t *end)

31 {

32 const uint8_t *a = p + 4 - ((intptr_t)p & 3);

34 for (end -= 3; p < a && p < end; p++) {

35 if (p[0] == 0 && p[1] == 0 && p[2] == 1)

36 return p;

37 }

39 for (end -= 3; p < end; p += 4) {

40 uint32_t x = *(const uint32_t*)p;

41 // if ((x - 0x01000100) & (~x) & 0x80008000) // little endian

42 // if ((x - 0x00010001) & (~x) & 0x00800080) // big endian

43 if ((x - 0x01010101) & (~x) & 0x80808080) { // generic

44 if (p[1] == 0) {

45 if (p[0] == 0 && p[2] == 1)

46 return p;

47 if (p[2] == 0 && p[3] == 1)

48 return p+1;

49 }

50 if (p[3] == 0) {

51 if (p[2] == 0 && p[4] == 1)

52 return p+2;

53 if (p[4] == 0 && p[5] == 1)

54 return p+3;

55 }

56 }

57 }

59 for (end += 3; p < end; p++) {

60 if (p[0] == 0 && p[1] == 0 && p[2] == 1)

61 return p;

62 }

64 return end + 3;

65 }

67 const uint8_t *ff_avc_find_startcode(const uint8_t *p, const uint8_t *end){

68 const uint8_t *out = avc_find_startcode_internal(p, end);

69 if(p<out && out<end && !out[-1]) out--;

70 return out;

71 }

73 static int avc_parse_nal_units(AVIOContext *pb, NALUList *list,

74 const uint8_t *buf_in, int size)

75 {

76 const uint8_t *p = buf_in;

77 const uint8_t *end = p + size;

78 const uint8_t *nal_start, *nal_end;

80 size = 0;

81 nal_start = ff_avc_find_startcode(p, end);

82 for (;;) {

83 const size_t nalu_limit = SIZE_MAX / sizeof(*list->nalus);

84 while (nal_start < end && !*(nal_start++));

85 if (nal_start == end)

86 break;

88 nal_end = ff_avc_find_startcode(nal_start, end);

89 if (pb) {

90 avio_wb32(pb, nal_end - nal_start);

91 avio_write(pb, nal_start, nal_end - nal_start);

92 } else if (list->nb_nalus >= nalu_limit) {

93 return AVERROR(ERANGE);

94 } else {

95 NALU *tmp = av_fast_realloc(list->nalus, &list->nalus_array_size,

96 (list->nb_nalus + 1) * sizeof(*list->nalus));

97 if (!tmp)

98 return AVERROR(ENOMEM);

99 list->nalus = tmp;

100 tmp[list->nb_nalus++] = (NALU){ .offset = nal_start - p,

101 .size = nal_end - nal_start };

102 }

103 size += 4 + nal_end - nal_start;

104 nal_start = nal_end;

105 }

106 return size;

107 }

108

109 int ff_avc_parse_nal_units(AVIOContext *pb, const uint8_t *buf_in, int size)

110 {

111 return avc_parse_nal_units(pb, NULL, buf_in, size);

112 }

113

114 int ff_nal_units_create_list(NALUList *list, const uint8_t *buf, int size)

115 {

116 list->nb_nalus = 0;

117 return avc_parse_nal_units(NULL, list, buf, size);

118 }

119

120 void ff_nal_units_write_list(const NALUList *list, AVIOContext *pb,

121 const uint8_t *buf)

122 {

123 for (unsigned i = 0; i < list->nb_nalus; i++) {

124 avio_wb32(pb, list->nalus[i].size);

125 avio_write(pb, buf + list->nalus[i].offset, list->nalus[i].size);

126 }

127 }

128

129 int ff_avc_parse_nal_units_buf(const uint8_t *buf_in, uint8_t **buf, int *size)

130 {

131 AVIOContext *pb;

132 int ret = avio_open_dyn_buf(&pb);

133 if(ret < 0)

134 return ret;

135

136 ff_avc_parse_nal_units(pb, buf_in, *size);

137

138 *size = avio_close_dyn_buf(pb, buf);

139 return 0;

140 }

141

142 int ff_isom_write_avcc(AVIOContext *pb, const uint8_t *data, int len)

143 {

144 AVIOContext *sps_pb = NULL, *pps_pb = NULL, *sps_ext_pb = NULL;

145 uint8_t *buf, *end, *start;

146 uint8_t *sps, *pps, *sps_ext;

147 uint32_t sps_size = 0, pps_size = 0, sps_ext_size = 0;

148 int ret, nb_sps = 0, nb_pps = 0, nb_sps_ext = 0;

149

150 if (len <= 6)

151 return AVERROR_INVALIDDATA;

152

153 /* check for H.264 start code */

154 if (AV_RB32(data) != 0x00000001 &&

155 AV_RB24(data) != 0x000001) {

156 avio_write(pb, data, len);

157 return 0;

158 }

159

160 ret = ff_avc_parse_nal_units_buf(data, &buf, &len);

161 if (ret < 0)

162 return ret;

163 start = buf;

164 end = buf + len;

165

166 ret = avio_open_dyn_buf(&sps_pb);

167 if (ret < 0)

168 goto fail;

169 ret = avio_open_dyn_buf(&pps_pb);

170 if (ret < 0)

171 goto fail;

172 ret = avio_open_dyn_buf(&sps_ext_pb);

173 if (ret < 0)

174 goto fail;

175

176 /* look for sps and pps */

177 while (end - buf > 4) {

178 uint32_t size;

179 uint8_t nal_type;

180 size = FFMIN(AV_RB32(buf), end - buf - 4);

181 buf += 4;

182 nal_type = buf[0] & 0x1f;

183

184 if (nal_type == 7) { /* SPS */

185 nb_sps++;

186 if (size > UINT16_MAX || nb_sps >= H264_MAX_SPS_COUNT) {

187 ret = AVERROR_INVALIDDATA;

188 goto fail;

189 }

190 avio_wb16(sps_pb, size);

191 avio_write(sps_pb, buf, size);

192 } else if (nal_type == 8) { /* PPS */

193 nb_pps++;

194 if (size > UINT16_MAX || nb_pps >= H264_MAX_PPS_COUNT) {

195 ret = AVERROR_INVALIDDATA;

196 goto fail;

197 }

198 avio_wb16(pps_pb, size);

199 avio_write(pps_pb, buf, size);

200 } else if (nal_type == 13) { /* SPS_EXT */

201 nb_sps_ext++;

202 if (size > UINT16_MAX || nb_sps_ext >= 256) {

203 ret = AVERROR_INVALIDDATA;

204 goto fail;

205 }

206 avio_wb16(sps_ext_pb, size);

207 avio_write(sps_ext_pb, buf, size);

208 }

209

210 buf += size;

211 }

212 sps_size = avio_get_dyn_buf(sps_pb, &sps);

213 pps_size = avio_get_dyn_buf(pps_pb, &pps);

214 sps_ext_size = avio_get_dyn_buf(sps_ext_pb, &sps_ext);

215

216 if (sps_size < 6 || !pps_size) {

217 ret = AVERROR_INVALIDDATA;

218 goto fail;

219 }

220

221 avio_w8(pb, 1); /* version */

222 avio_w8(pb, sps[3]); /* profile */

223 avio_w8(pb, sps[4]); /* profile compat */

224 avio_w8(pb, sps[5]); /* level */

225 avio_w8(pb, 0xff); /* 6 bits reserved (111111) + 2 bits nal size length - 1 (11) */

226 avio_w8(pb, 0xe0 | nb_sps); /* 3 bits reserved (111) + 5 bits number of sps */

227

228 avio_write(pb, sps, sps_size);

229 avio_w8(pb, nb_pps); /* number of pps */

230 avio_write(pb, pps, pps_size);

231

232 if (sps[3] != 66 && sps[3] != 77 && sps[3] != 88) {

233 H264SPS seq;

234 ret = ff_avc_decode_sps(&seq, sps + 3, sps_size - 3);

235 if (ret < 0)

236 goto fail;

237

238 avio_w8(pb, 0xfc | seq.chroma_format_idc); /* 6 bits reserved (111111) + chroma_format_idc */

239 avio_w8(pb, 0xf8 | (seq.bit_depth_luma - 8)); /* 5 bits reserved (11111) + bit_depth_luma_minus8 */

240 avio_w8(pb, 0xf8 | (seq.bit_depth_chroma - 8)); /* 5 bits reserved (11111) + bit_depth_chroma_minus8 */

241 avio_w8(pb, nb_sps_ext); /* number of sps ext */

242 if (nb_sps_ext)

243 avio_write(pb, sps_ext, sps_ext_size);

244 }

245

246 fail:

247 ffio_free_dyn_buf(&sps_pb);

248 ffio_free_dyn_buf(&pps_pb);

249 ffio_free_dyn_buf(&sps_ext_pb);

250 av_free(start);

251

252 return ret;

253 }

254

255 int ff_avc_write_annexb_extradata(const uint8_t *in, uint8_t **buf, int *size)

256 {

257 uint16_t sps_size, pps_size;

258 uint8_t *out;

259 int out_size;

260

261 *buf = NULL;

262 if (*size >= 4 && (AV_RB32(in) == 0x00000001 || AV_RB24(in) == 0x000001))

263 return 0;

264 if (*size < 11 || in[0] != 1)

265 return AVERROR_INVALIDDATA;

266

267 sps_size = AV_RB16(&in[6]);

268 if (11 + sps_size > *size)

269 return AVERROR_INVALIDDATA;

270 pps_size = AV_RB16(&in[9 + sps_size]);

271 if (11 + sps_size + pps_size > *size)

272 return AVERROR_INVALIDDATA;

273 out_size = 8 + sps_size + pps_size;

274 out = av_mallocz(out_size + AV_INPUT_BUFFER_PADDING_SIZE);

275 if (!out)

276 return AVERROR(ENOMEM);

277 AV_WB32(&out[0], 0x00000001);

278 memcpy(out + 4, &in[8], sps_size);

279 AV_WB32(&out[4 + sps_size], 0x00000001);

280 memcpy(out + 8 + sps_size, &in[11 + sps_size], pps_size);

281 *buf = out;

282 *size = out_size;

283 return 0;

284 }

285

286 const uint8_t *ff_avc_mp4_find_startcode(const uint8_t *start,

287 const uint8_t *end,

288 int nal_length_size)

289 {

290 unsigned int res = 0;

291

292 if (end - start < nal_length_size)

293 return NULL;

294 while (nal_length_size--)

295 res = (res << 8) | *start++;

296

297 if (res > end - start)

298 return NULL;

299

300 return start + res;

301 }

302

303 uint8_t *ff_nal_unit_extract_rbsp(const uint8_t *src, uint32_t src_len,

304 uint32_t *dst_len, int header_len)

305 {

306 uint8_t *dst;

307 uint32_t i, len;

308

309 dst = av_malloc(src_len + AV_INPUT_BUFFER_PADDING_SIZE);

310 if (!dst)

311 return NULL;

312

313 /* NAL unit header */

314 i = len = 0;

315 while (i < header_len && i < src_len)

316 dst[len++] = src[i++];

317

318 while (i + 2 < src_len)

319 if (!src[i] && !src[i + 1] && src[i + 2] == 3) {

320 dst[len++] = src[i++];

321 dst[len++] = src[i++];

322 i++; // remove emulation_prevention_three_byte

323 } else

324 dst[len++] = src[i++];

325

326 while (i < src_len)

327 dst[len++] = src[i++];

328

329 memset(dst + len, 0, AV_INPUT_BUFFER_PADDING_SIZE);

330

331 *dst_len = len;

332 return dst;

333 }

334

335 static const AVRational avc_sample_aspect_ratio[17] = {

336 { 0, 1 },

337 { 1, 1 },

338 { 12, 11 },

339 { 10, 11 },

340 { 16, 11 },

341 { 40, 33 },

342 { 24, 11 },

343 { 20, 11 },

344 { 32, 11 },

345 { 80, 33 },

346 { 18, 11 },

347 { 15, 11 },

348 { 64, 33 },

349 { 160, 99 },

350 { 4, 3 },

351 { 3, 2 },

352 { 2, 1 },

353 };

354

355 static inline int get_ue_golomb(GetBitContext *gb) {

356 int i;

357 for (i = 0; i < 32 && !get_bits1(gb); i++)

358 ;

359 return get_bitsz(gb, i) + (1 << i) - 1;

360 }

361

362 static inline int get_se_golomb(GetBitContext *gb) {

363 int v = get_ue_golomb(gb) + 1;

364 int sign = -(v & 1);

365 return ((v >> 1) ^ sign) - sign;

366 }

367

368 int ff_avc_decode_sps(H264SPS *sps, const uint8_t *buf, int buf_size)

369 {

370 int i, j, ret, rbsp_size, aspect_ratio_idc, pic_order_cnt_type;

371 int num_ref_frames_in_pic_order_cnt_cycle;

372 int delta_scale, lastScale = 8, nextScale = 8;

373 int sizeOfScalingList;

374 GetBitContext gb;

375 uint8_t *rbsp_buf;

376

377 rbsp_buf = ff_nal_unit_extract_rbsp(buf, buf_size, &rbsp_size, 0);

378 if (!rbsp_buf)

379 return AVERROR(ENOMEM);

380

381 ret = init_get_bits8(&gb, rbsp_buf, rbsp_size);

382 if (ret < 0)

383 goto end;

384

385 memset(sps, 0, sizeof(*sps));

386

387 sps->profile_idc = get_bits(&gb, 8);

388 sps->constraint_set_flags |= get_bits1(&gb) << 0; // constraint_set0_flag

389 sps->constraint_set_flags |= get_bits1(&gb) << 1; // constraint_set1_flag

390 sps->constraint_set_flags |= get_bits1(&gb) << 2; // constraint_set2_flag

391 sps->constraint_set_flags |= get_bits1(&gb) << 3; // constraint_set3_flag

392 sps->constraint_set_flags |= get_bits1(&gb) << 4; // constraint_set4_flag

393 sps->constraint_set_flags |= get_bits1(&gb) << 5; // constraint_set5_flag

394 skip_bits(&gb, 2); // reserved_zero_2bits

395 sps->level_idc = get_bits(&gb, 8);

396 sps->id = get_ue_golomb(&gb);

397

398 if (sps->profile_idc == 100 || sps->profile_idc == 110 ||

399 sps->profile_idc == 122 || sps->profile_idc == 244 || sps->profile_idc == 44 ||

400 sps->profile_idc == 83 || sps->profile_idc == 86 || sps->profile_idc == 118 ||

401 sps->profile_idc == 128 || sps->profile_idc == 138 || sps->profile_idc == 139 ||

402 sps->profile_idc == 134) {

403 sps->chroma_format_idc = get_ue_golomb(&gb); // chroma_format_idc

404 if (sps->chroma_format_idc == 3) {

405 skip_bits1(&gb); // separate_colour_plane_flag

406 }

407 sps->bit_depth_luma = get_ue_golomb(&gb) + 8;

408 sps->bit_depth_chroma = get_ue_golomb(&gb) + 8;

409 skip_bits1(&gb); // qpprime_y_zero_transform_bypass_flag

410 if (get_bits1(&gb)) { // seq_scaling_matrix_present_flag

411 for (i = 0; i < ((sps->chroma_format_idc != 3) ? 8 : 12); i++) {

412 if (!get_bits1(&gb)) // seq_scaling_list_present_flag

413 continue;

414 lastScale = 8;

415 nextScale = 8;

416 sizeOfScalingList = i < 6 ? 16 : 64;

417 for (j = 0; j < sizeOfScalingList; j++) {

418 if (nextScale != 0) {

419 delta_scale = get_se_golomb(&gb);

420 nextScale = (lastScale + delta_scale) & 0xff;

421 }

422 lastScale = nextScale == 0 ? lastScale : nextScale;

423 }

424 }

425 }

426 } else {

427 sps->chroma_format_idc = 1;

428 sps->bit_depth_luma = 8;

429 sps->bit_depth_chroma = 8;

430 }

431

432 get_ue_golomb(&gb); // log2_max_frame_num_minus4

433 pic_order_cnt_type = get_ue_golomb(&gb);

434

435 if (pic_order_cnt_type == 0) {

436 get_ue_golomb(&gb); // log2_max_pic_order_cnt_lsb_minus4

437 } else if (pic_order_cnt_type == 1) {

438 skip_bits1(&gb); // delta_pic_order_always_zero

439 get_se_golomb(&gb); // offset_for_non_ref_pic

440 get_se_golomb(&gb); // offset_for_top_to_bottom_field

441 num_ref_frames_in_pic_order_cnt_cycle = get_ue_golomb(&gb);

442 for (i = 0; i < num_ref_frames_in_pic_order_cnt_cycle; i++)

443 get_se_golomb(&gb); // offset_for_ref_frame

444 }

445

446 get_ue_golomb(&gb); // max_num_ref_frames

447 skip_bits1(&gb); // gaps_in_frame_num_value_allowed_flag

448 get_ue_golomb(&gb); // pic_width_in_mbs_minus1

449 get_ue_golomb(&gb); // pic_height_in_map_units_minus1

450

451 sps->frame_mbs_only_flag = get_bits1(&gb);

452 if (!sps->frame_mbs_only_flag)

453 skip_bits1(&gb); // mb_adaptive_frame_field_flag

454

455 skip_bits1(&gb); // direct_8x8_inference_flag

456

457 if (get_bits1(&gb)) { // frame_cropping_flag

458 get_ue_golomb(&gb); // frame_crop_left_offset

459 get_ue_golomb(&gb); // frame_crop_right_offset

460 get_ue_golomb(&gb); // frame_crop_top_offset

461 get_ue_golomb(&gb); // frame_crop_bottom_offset

462 }

463

464 if (get_bits1(&gb)) { // vui_parameters_present_flag

465 if (get_bits1(&gb)) { // aspect_ratio_info_present_flag

466 aspect_ratio_idc = get_bits(&gb, 8);

467 if (aspect_ratio_idc == 0xff) {

468 sps->sar.num = get_bits(&gb, 16);

469 sps->sar.den = get_bits(&gb, 16);

470 } else if (aspect_ratio_idc < FF_ARRAY_ELEMS(avc_sample_aspect_ratio)) {

471 sps->sar = avc_sample_aspect_ratio[aspect_ratio_idc];

472 }

473 }

474 }

475

476 if (!sps->sar.den) {

477 sps->sar.num = 1;

478 sps->sar.den = 1;

479 }

480

481 ret = 0;

482 end:

483 av_free(rbsp_buf);

484 return ret;

485 }

H264SPS

Definition: avc.h:69

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

out

FILE * out

Definition: movenc.c:54

H264SPS::bit_depth_chroma

uint8_t bit_depth_chroma

Definition: avc.h:76

ff_nal_units_create_list

int ff_nal_units_create_list(NALUList *list, const uint8_t *buf, int size)

Definition: avc.c:114

out_size

int out_size

Definition: movenc.c:55

tmp

static uint8_t tmp[11]

Definition: aes_ctr.c:28

data

const char data[16]

Definition: mxf.c:146

avc_parse_nal_units

static int avc_parse_nal_units(AVIOContext *pb, NALUList *list, const uint8_t *buf_in, int size)

Definition: avc.c:73

avio_get_dyn_buf

int avio_get_dyn_buf(AVIOContext *s, uint8_t **pbuffer)

Return the written size and a pointer to the buffer.

Definition: aviobuf.c:1487

av_malloc

#define av_malloc(s)

Definition: tableprint_vlc.h:30

skip_bits

static void skip_bits(GetBitContext *s, int n)

Definition: get_bits.h:371

H264SPS::bit_depth_luma

uint8_t bit_depth_luma

Definition: avc.h:75

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

GetBitContext

Definition: get_bits.h:107

ff_avc_decode_sps

int ff_avc_decode_sps(H264SPS *sps, const uint8_t *buf, int buf_size)

Definition: avc.c:368

get_se_golomb

static int get_se_golomb(GetBitContext *gb)

Definition: avc.c:362

avio_close_dyn_buf

int avio_close_dyn_buf(AVIOContext *s, uint8_t **pbuffer)

Return the written size and a pointer to the buffer.

Definition: aviobuf.c:1520

FF_ARRAY_ELEMS

#define FF_ARRAY_ELEMS(a)

Definition: sinewin_tablegen.c:29

init_get_bits8

static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)

Initialize GetBitContext.

Definition: get_bits.h:524

avio_open_dyn_buf

int avio_open_dyn_buf(AVIOContext **s)

Open a write only memory stream.

Definition: aviobuf.c:1475

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

ff_nal_unit_extract_rbsp

uint8_t * ff_nal_unit_extract_rbsp(const uint8_t *src, uint32_t src_len, uint32_t *dst_len, int header_len)

Definition: avc.c:303

get_bits.h

NULL

#define NULL

Definition: coverity.c:32

avc_sample_aspect_ratio

static const AVRational avc_sample_aspect_ratio[17]

Definition: avc.c:335

AVRational

Rational number (pair of numerator and denominator).

Definition: rational.h:58

get_ue_golomb

static int get_ue_golomb(GetBitContext *gb)

Definition: avc.c:355

get_bits1

static unsigned int get_bits1(GetBitContext *s)

Definition: get_bits.h:378

avc.h

list

Definition: filter_design.txt:25

ff_avc_parse_nal_units_buf

int ff_avc_parse_nal_units_buf(const uint8_t *buf_in, uint8_t **buf, int *size)

Definition: avc.c:129

avio_w8

void avio_w8(AVIOContext *s, int b)

Definition: aviobuf.c:200

AV_WB32

#define AV_WB32(p, v)

Definition: intreadwrite.h:419

ff_nal_units_write_list

void ff_nal_units_write_list(const NALUList *list, AVIOContext *pb, const uint8_t *buf)

Definition: avc.c:120

AVIOContext

Bytestream IO Context.

Definition: avio.h:166

ff_avc_parse_nal_units

int ff_avc_parse_nal_units(AVIOContext *pb, const uint8_t *buf_in, int size)

Definition: avc.c:109

pps

static int FUNC() pps(CodedBitstreamContext *ctx, RWContext *rw, H264RawPPS *current)

Definition: cbs_h264_syntax_template.c:404

ff_isom_write_avcc

int ff_isom_write_avcc(AVIOContext *pb, const uint8_t *data, int len)

Definition: avc.c:142

size

int size

Definition: twinvq_data.h:10344

avio.h

AV_RB32

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_RB32

Definition: bytestream.h:96

avio_write

void avio_write(AVIOContext *s, const unsigned char *buf, int size)

Definition: aviobuf.c:222

avio_wb32

void avio_wb32(AVIOContext *s, unsigned int val)

Definition: aviobuf.c:386

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

skip_bits1

static void skip_bits1(GetBitContext *s)

Definition: get_bits.h:403

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

Definition: cbs_h2645.c:269

avio_internal.h

H264SPS::chroma_format_idc

uint8_t chroma_format_idc

Definition: avc.h:74

FFMIN

#define FFMIN(a, b)

Definition: macros.h:49

NALU

Definition: avc.h:29

av_mallocz

void * av_mallocz(size_t size)

Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...

Definition: mem.c:254

len

int len

Definition: vorbis_enc_data.h:426

avc_find_startcode_internal

static const uint8_t * avc_find_startcode_internal(const uint8_t *p, const uint8_t *end)

Definition: avc.c:30

ffio_free_dyn_buf

void ffio_free_dyn_buf(AVIOContext **s)

Free a dynamic buffer.

Definition: aviobuf.c:1548

ret

Definition: filter_design.txt:187

sps

static int FUNC() sps(CodedBitstreamContext *ctx, RWContext *rw, H264RawSPS *current)

Definition: cbs_h264_syntax_template.c:260

avformat.h

AV_INPUT_BUFFER_PADDING_SIZE

#define AV_INPUT_BUFFER_PADDING_SIZE

Definition: defs.h:40

NALUList

Definition: avc.h:34

ff_avc_write_annexb_extradata

int ff_avc_write_annexb_extradata(const uint8_t *in, uint8_t **buf, int *size)

Definition: avc.c:255

get_bitsz

static av_always_inline int get_bitsz(GetBitContext *s, int n)

Read 0-25 bits.

Definition: get_bits.h:341

av_free

#define av_free(p)

Definition: tableprint_vlc.h:33

src

INIT_CLIP pixel * src

Definition: h264pred_template.c:418

h264.h

avio_wb16

void avio_wb16(AVIOContext *s, unsigned int val)

Definition: aviobuf.c:464

AVERROR_INVALIDDATA

#define AVERROR_INVALIDDATA

Invalid data found when processing input.

Definition: error.h:61

H264_MAX_PPS_COUNT

@ H264_MAX_PPS_COUNT

Definition: h264.h:73

AV_RB24

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_RB24

Definition: bytestream.h:97

ff_avc_mp4_find_startcode

const uint8_t * ff_avc_mp4_find_startcode(const uint8_t *start, const uint8_t *end, int nal_length_size)

Definition: avc.c:286

H264_MAX_SPS_COUNT

@ H264_MAX_SPS_COUNT

Definition: h264.h:71

AV_RB16

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_RB16

Definition: bytestream.h:98

ff_avc_find_startcode

const uint8_t * ff_avc_find_startcode(const uint8_t *p, const uint8_t *end)

Definition: avc.c:67

Generated on Tue Feb 28 2023 21:34:02 for FFmpeg by doxygen 1.8.17