FFmpeg: libavutil/imgutils.c Source File

FFmpeg

[フレーム]

libavutil

imgutils.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 /**

20 * @file

21 * misc image utilities

22 */

24 #include "avassert.h"

25 #include "common.h"

26 #include "imgutils.h"

27 #include "imgutils_internal.h"

28 #include "internal.h"

29 #include "intreadwrite.h"

30 #include "log.h"

31 #include "mathematics.h"

32 #include "pixdesc.h"

33 #include "rational.h"

35 void av_image_fill_max_pixsteps(int max_pixsteps[4], int max_pixstep_comps[4],

36 const AVPixFmtDescriptor *pixdesc)

37 {

38 int i;

39 memset(max_pixsteps, 0, 4*sizeof(max_pixsteps[0]));

40 if (max_pixstep_comps)

41 memset(max_pixstep_comps, 0, 4*sizeof(max_pixstep_comps[0]));

43 for (i = 0; i < 4; i++) {

44 const AVComponentDescriptor *comp = &(pixdesc->comp[i]);

45 if (comp->step > max_pixsteps[comp->plane]) {

46 max_pixsteps[comp->plane] = comp->step;

47 if (max_pixstep_comps)

48 max_pixstep_comps[comp->plane] = i;

49 }

50 }

51 }

53 static inline

54 int image_get_linesize(int width, int plane,

55 int max_step, int max_step_comp,

56 const AVPixFmtDescriptor *desc)

57 {

58 int s, shifted_w, linesize;

60 if (!desc)

61 return AVERROR(EINVAL);

63 if (width < 0)

64 return AVERROR(EINVAL);

65 s = (max_step_comp == 1 || max_step_comp == 2) ? desc->log2_chroma_w : 0;

66 shifted_w = ((width + (1 << s) - 1)) >> s;

67 if (shifted_w && max_step > INT_MAX / shifted_w)

68 return AVERROR(EINVAL);

69 linesize = max_step * shifted_w;

71 if (desc->flags & AV_PIX_FMT_FLAG_BITSTREAM)

72 linesize = (linesize + 7) >> 3;

73 return linesize;

74 }

76 int av_image_get_linesize(enum AVPixelFormat pix_fmt, int width, int plane)

77 {

78 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);

79 int max_step [4]; /* max pixel step for each plane */

80 int max_step_comp[4]; /* the component for each plane which has the max pixel step */

82 if (!desc || desc->flags & AV_PIX_FMT_FLAG_HWACCEL)

83 return AVERROR(EINVAL);

85 av_image_fill_max_pixsteps(max_step, max_step_comp, desc);

86 return image_get_linesize(width, plane, max_step[plane], max_step_comp[plane], desc);

87 }

89 int av_image_fill_linesizes(int linesizes[4], enum AVPixelFormat pix_fmt, int width)

90 {

91 int i, ret;

92 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);

93 int max_step [4]; /* max pixel step for each plane */

94 int max_step_comp[4]; /* the component for each plane which has the max pixel step */

96 memset(linesizes, 0, 4*sizeof(linesizes[0]));

98 if (!desc || desc->flags & AV_PIX_FMT_FLAG_HWACCEL)

99 return AVERROR(EINVAL);

100

101 av_image_fill_max_pixsteps(max_step, max_step_comp, desc);

102 for (i = 0; i < 4; i++) {

103 if ((ret = image_get_linesize(width, i, max_step[i], max_step_comp[i], desc)) < 0)

104 return ret;

105 linesizes[i] = ret;

106 }

107

108 return 0;

109 }

110

111 int av_image_fill_plane_sizes(size_t sizes[4], enum AVPixelFormat pix_fmt,

112 int height, const ptrdiff_t linesizes[4])

113 {

114 int i, has_plane[4] = { 0 };

115

116 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);

117 memset(sizes , 0, sizeof(sizes[0])*4);

118

119 if (!desc || desc->flags & AV_PIX_FMT_FLAG_HWACCEL)

120 return AVERROR(EINVAL);

121

122 if (linesizes[0] > SIZE_MAX / height)

123 return AVERROR(EINVAL);

124 sizes[0] = linesizes[0] * (size_t)height;

125

126 if (desc->flags & AV_PIX_FMT_FLAG_PAL) {

127 sizes[1] = 256 * 4; /* palette is stored here as 256 32 bits words */

128 return 0;

129 }

130

131 for (i = 0; i < 4; i++)

132 has_plane[desc->comp[i].plane] = 1;

133

134 for (i = 1; i < 4 && has_plane[i]; i++) {

135 int h, s = (i == 1 || i == 2) ? desc->log2_chroma_h : 0;

136 h = (height + (1 << s) - 1) >> s;

137 if (linesizes[i] > SIZE_MAX / h)

138 return AVERROR(EINVAL);

139 sizes[i] = (size_t)h * linesizes[i];

140 }

141

142 return 0;

143 }

144

145 int av_image_fill_pointers(uint8_t *data[4], enum AVPixelFormat pix_fmt, int height,

146 uint8_t *ptr, const int linesizes[4])

147 {

148 int i, ret;

149 ptrdiff_t linesizes1[4];

150 size_t sizes[4];

151

152 memset(data , 0, sizeof(data[0])*4);

153

154 for (i = 0; i < 4; i++)

155 linesizes1[i] = linesizes[i];

156

157 ret = av_image_fill_plane_sizes(sizes, pix_fmt, height, linesizes1);

158 if (ret < 0)

159 return ret;

160

161 ret = 0;

162 for (i = 0; i < 4; i++) {

163 if (sizes[i] > INT_MAX - ret)

164 return AVERROR(EINVAL);

165 ret += sizes[i];

166 }

167

168 if (!ptr)

169 return ret;

170

171 data[0] = ptr;

172 for (i = 1; i < 4 && sizes[i]; i++)

173 data[i] = data[i - 1] + sizes[i - 1];

174

175 return ret;

176 }

177

178 int avpriv_set_systematic_pal2(uint32_t pal[256], enum AVPixelFormat pix_fmt)

179 {

180 int i;

181

182 for (i = 0; i < 256; i++) {

183 int r, g, b;

184

185 switch (pix_fmt) {

186 case AV_PIX_FMT_RGB8:

187 r = (i>>5 )*36;

188 g = ((i>>2)&7)*36;

189 b = (i&3 )*85;

190 break;

191 case AV_PIX_FMT_BGR8:

192 b = (i>>6 )*85;

193 g = ((i>>3)&7)*36;

194 r = (i&7 )*36;

195 break;

196 case AV_PIX_FMT_RGB4_BYTE:

197 r = (i>>3 )*255;

198 g = ((i>>1)&3)*85;

199 b = (i&1 )*255;

200 break;

201 case AV_PIX_FMT_BGR4_BYTE:

202 b = (i>>3 )*255;

203 g = ((i>>1)&3)*85;

204 r = (i&1 )*255;

205 break;

206 case AV_PIX_FMT_GRAY8:

207 r = b = g = i;

208 break;

209 default:

210 return AVERROR(EINVAL);

211 }

212 pal[i] = b + (g << 8) + (r << 16) + (0xFFU << 24);

213 }

214

215 return 0;

216 }

217

218 int av_image_alloc(uint8_t *pointers[4], int linesizes[4],

219 int w, int h, enum AVPixelFormat pix_fmt, int align)

220 {

221 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);

222 int i, ret;

223 ptrdiff_t linesizes1[4];

224 size_t total_size, sizes[4];

225 uint8_t *buf;

226

227 if (!desc)

228 return AVERROR(EINVAL);

229

230 if ((ret = av_image_check_size(w, h, 0, NULL)) < 0)

231 return ret;

232 if ((ret = av_image_fill_linesizes(linesizes, pix_fmt, align>7 ? FFALIGN(w, 8) : w)) < 0)

233 return ret;

234

235 for (i = 0; i < 4; i++) {

236 linesizes[i] = FFALIGN(linesizes[i], align);

237 linesizes1[i] = linesizes[i];

238 }

239

240 if ((ret = av_image_fill_plane_sizes(sizes, pix_fmt, h, linesizes1)) < 0)

241 return ret;

242 total_size = align;

243 for (i = 0; i < 4; i++) {

244 if (total_size > SIZE_MAX - sizes[i])

245 return AVERROR(EINVAL);

246 total_size += sizes[i];

247 }

248 buf = av_malloc(total_size);

249 if (!buf)

250 return AVERROR(ENOMEM);

251 if ((ret = av_image_fill_pointers(pointers, pix_fmt, h, buf, linesizes)) < 0) {

252 av_free(buf);

253 return ret;

254 }

255 if (desc->flags & AV_PIX_FMT_FLAG_PAL) {

256 avpriv_set_systematic_pal2((uint32_t*)pointers[1], pix_fmt);

257 if (align < 4) {

258 av_log(NULL, AV_LOG_ERROR, "Formats with a palette require a minimum alignment of 4\n");

259 av_free(buf);

260 return AVERROR(EINVAL);

261 }

262 }

263

264 if (desc->flags & AV_PIX_FMT_FLAG_PAL && pointers[1] &&

265 pointers[1] - pointers[0] > linesizes[0] * h) {

266 /* zero-initialize the padding before the palette */

267 memset(pointers[0] + linesizes[0] * h, 0,

268 pointers[1] - pointers[0] - linesizes[0] * h);

269 }

270

271 return ret;

272 }

273

274 typedef struct ImgUtils {

275 const AVClass *class;

276 int log_offset;

277 void *log_ctx;

278 } ImgUtils;

279

280 static const AVClass imgutils_class = {

281 .class_name = "IMGUTILS",

282 .item_name = av_default_item_name,

283 .option = NULL,

284 .version = LIBAVUTIL_VERSION_INT,

285 .log_level_offset_offset = offsetof(ImgUtils, log_offset),

286 .parent_log_context_offset = offsetof(ImgUtils, log_ctx),

287 };

288

289 int av_image_check_size2(unsigned int w, unsigned int h, int64_t max_pixels, enum AVPixelFormat pix_fmt, int log_offset, void *log_ctx)

290 {

291 ImgUtils imgutils = {

292 .class = &imgutils_class,

293 .log_offset = log_offset,

294 .log_ctx = log_ctx,

295 };

296 int64_t stride = av_image_get_linesize(pix_fmt, w, 0);

297 if (stride <= 0)

298 stride = 8LL*w;

299 stride += 128*8;

300

301 if ((int)w<=0 || (int)h<=0 || stride >= INT_MAX || stride*(uint64_t)(h+128) >= INT_MAX) {

302 av_log(&imgutils, AV_LOG_ERROR, "Picture size %ux%u is invalid\n", w, h);

303 return AVERROR(EINVAL);

304 }

305

306 if (max_pixels < INT64_MAX) {

307 if (w*(int64_t)h > max_pixels) {

308 av_log(&imgutils, AV_LOG_ERROR,

309 "Picture size %ux%u exceeds specified max pixel count %"PRId64", see the documentation if you wish to increase it\n",

310 w, h, max_pixels);

311 return AVERROR(EINVAL);

312 }

313 }

314

315 return 0;

316 }

317

318 int av_image_check_size(unsigned int w, unsigned int h, int log_offset, void *log_ctx)

319 {

320 return av_image_check_size2(w, h, INT64_MAX, AV_PIX_FMT_NONE, log_offset, log_ctx);

321 }

322

323 int av_image_check_sar(unsigned int w, unsigned int h, AVRational sar)

324 {

325 int64_t scaled_dim;

326

327 if (sar.den <= 0 || sar.num < 0)

328 return AVERROR(EINVAL);

329

330 if (!sar.num || sar.num == sar.den)

331 return 0;

332

333 if (sar.num < sar.den)

334 scaled_dim = av_rescale_rnd(w, sar.num, sar.den, AV_ROUND_ZERO);

335 else

336 scaled_dim = av_rescale_rnd(h, sar.den, sar.num, AV_ROUND_ZERO);

337

338 if (scaled_dim > 0)

339 return 0;

340

341 return AVERROR(EINVAL);

342 }

343

344 static void image_copy_plane(uint8_t *dst, ptrdiff_t dst_linesize,

345 const uint8_t *src, ptrdiff_t src_linesize,

346 ptrdiff_t bytewidth, int height)

347 {

348 if (!dst || !src)

349 return;

350 av_assert0(FFABS(src_linesize) >= bytewidth);

351 av_assert0(FFABS(dst_linesize) >= bytewidth);

352 for (;height > 0; height--) {

353 memcpy(dst, src, bytewidth);

354 dst += dst_linesize;

355 src += src_linesize;

356 }

357 }

358

359 void av_image_copy_plane_uc_from(uint8_t *dst, ptrdiff_t dst_linesize,

360 const uint8_t *src, ptrdiff_t src_linesize,

361 ptrdiff_t bytewidth, int height)

362 {

363 int ret = -1;

364

365 #if ARCH_X86

366 ret = ff_image_copy_plane_uc_from_x86(dst, dst_linesize, src, src_linesize,

367 bytewidth, height);

368 #endif

369

370 if (ret < 0)

371 image_copy_plane(dst, dst_linesize, src, src_linesize, bytewidth, height);

372 }

373

374 void av_image_copy_plane(uint8_t *dst, int dst_linesize,

375 const uint8_t *src, int src_linesize,

376 int bytewidth, int height)

377 {

378 image_copy_plane(dst, dst_linesize, src, src_linesize, bytewidth, height);

379 }

380

381 static void image_copy(uint8_t *dst_data[4], const ptrdiff_t dst_linesizes[4],

382 const uint8_t *src_data[4], const ptrdiff_t src_linesizes[4],

383 enum AVPixelFormat pix_fmt, int width, int height,

384 void (*copy_plane)(uint8_t *, ptrdiff_t, const uint8_t *,

385 ptrdiff_t, ptrdiff_t, int))

386 {

387 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);

388

389 if (!desc || desc->flags & AV_PIX_FMT_FLAG_HWACCEL)

390 return;

391

392 if (desc->flags & AV_PIX_FMT_FLAG_PAL) {

393 copy_plane(dst_data[0], dst_linesizes[0],

394 src_data[0], src_linesizes[0],

395 width, height);

396 /* copy the palette */

397 if ((desc->flags & AV_PIX_FMT_FLAG_PAL) || (dst_data[1] && src_data[1]))

398 memcpy(dst_data[1], src_data[1], 4*256);

399 } else {

400 int i, planes_nb = 0;

401

402 for (i = 0; i < desc->nb_components; i++)

403 planes_nb = FFMAX(planes_nb, desc->comp[i].plane + 1);

404

405 for (i = 0; i < planes_nb; i++) {

406 int h = height;

407 ptrdiff_t bwidth = av_image_get_linesize(pix_fmt, width, i);

408 if (bwidth < 0) {

409 av_log(NULL, AV_LOG_ERROR, "av_image_get_linesize failed\n");

410 return;

411 }

412 if (i == 1 || i == 2) {

413 h = AV_CEIL_RSHIFT(height, desc->log2_chroma_h);

414 }

415 copy_plane(dst_data[i], dst_linesizes[i],

416 src_data[i], src_linesizes[i],

417 bwidth, h);

418 }

419 }

420 }

421

422 void av_image_copy(uint8_t *dst_data[4], int dst_linesizes[4],

423 const uint8_t *src_data[4], const int src_linesizes[4],

424 enum AVPixelFormat pix_fmt, int width, int height)

425 {

426 ptrdiff_t dst_linesizes1[4], src_linesizes1[4];

427 int i;

428

429 for (i = 0; i < 4; i++) {

430 dst_linesizes1[i] = dst_linesizes[i];

431 src_linesizes1[i] = src_linesizes[i];

432 }

433

434 image_copy(dst_data, dst_linesizes1, src_data, src_linesizes1, pix_fmt,

435 width, height, image_copy_plane);

436 }

437

438 void av_image_copy_uc_from(uint8_t *dst_data[4], const ptrdiff_t dst_linesizes[4],

439 const uint8_t *src_data[4], const ptrdiff_t src_linesizes[4],

440 enum AVPixelFormat pix_fmt, int width, int height)

441 {

442 image_copy(dst_data, dst_linesizes, src_data, src_linesizes, pix_fmt,

443 width, height, av_image_copy_plane_uc_from);

444 }

445

446 int av_image_fill_arrays(uint8_t *dst_data[4], int dst_linesize[4],

447 const uint8_t *src, enum AVPixelFormat pix_fmt,

448 int width, int height, int align)

449 {

450 int ret, i;

451

452 ret = av_image_check_size(width, height, 0, NULL);

453 if (ret < 0)

454 return ret;

455

456 ret = av_image_fill_linesizes(dst_linesize, pix_fmt, width);

457 if (ret < 0)

458 return ret;

459

460 for (i = 0; i < 4; i++)

461 dst_linesize[i] = FFALIGN(dst_linesize[i], align);

462

463 return av_image_fill_pointers(dst_data, pix_fmt, height, (uint8_t *)src, dst_linesize);

464 }

465

466 int av_image_get_buffer_size(enum AVPixelFormat pix_fmt,

467 int width, int height, int align)

468 {

469 int ret, i;

470 int linesize[4];

471 ptrdiff_t aligned_linesize[4];

472 size_t sizes[4];

473 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);

474 if (!desc)

475 return AVERROR(EINVAL);

476

477 ret = av_image_check_size(width, height, 0, NULL);

478 if (ret < 0)

479 return ret;

480

481 ret = av_image_fill_linesizes(linesize, pix_fmt, width);

482 if (ret < 0)

483 return ret;

484

485 for (i = 0; i < 4; i++)

486 aligned_linesize[i] = FFALIGN(linesize[i], align);

487

488 ret = av_image_fill_plane_sizes(sizes, pix_fmt, height, aligned_linesize);

489 if (ret < 0)

490 return ret;

491

492 ret = 0;

493 for (i = 0; i < 4; i++) {

494 if (sizes[i] > INT_MAX - ret)

495 return AVERROR(EINVAL);

496 ret += sizes[i];

497 }

498 return ret;

499 }

500

501 int av_image_copy_to_buffer(uint8_t *dst, int dst_size,

502 const uint8_t * const src_data[4],

503 const int src_linesize[4],

504 enum AVPixelFormat pix_fmt,

505 int width, int height, int align)

506 {

507 int i, j, nb_planes = 0, linesize[4];

508 int size = av_image_get_buffer_size(pix_fmt, width, height, align);

509 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);

510 int ret;

511

512 if (size > dst_size || size < 0 || !desc)

513 return AVERROR(EINVAL);

514

515 for (i = 0; i < desc->nb_components; i++)

516 nb_planes = FFMAX(desc->comp[i].plane, nb_planes);

517

518 nb_planes++;

519

520 ret = av_image_fill_linesizes(linesize, pix_fmt, width);

521 av_assert0(ret >= 0); // was checked previously

522

523 for (i = 0; i < nb_planes; i++) {

524 int h, shift = (i == 1 || i == 2) ? desc->log2_chroma_h : 0;

525 const uint8_t *src = src_data[i];

526 h = (height + (1 << shift) - 1) >> shift;

527

528 for (j = 0; j < h; j++) {

529 memcpy(dst, src, linesize[i]);

530 dst += FFALIGN(linesize[i], align);

531 src += src_linesize[i];

532 }

533 }

534

535 if (desc->flags & AV_PIX_FMT_FLAG_PAL) {

536 uint32_t *d32 = (uint32_t *)dst;

537

538 for (i = 0; i<256; i++)

539 AV_WL32(d32 + i, AV_RN32(src_data[1] + 4*i));

540 }

541

542 return size;

543 }

544

545 // Fill dst[0..dst_size] with the bytes in clear[0..clear_size]. The clear

546 // bytes are repeated until dst_size is reached. If dst_size is unaligned (i.e.

547 // dst_size%clear_size!=0), the remaining data will be filled with the beginning

548 // of the clear data only.

549 static void memset_bytes(uint8_t *dst, size_t dst_size, uint8_t *clear,

550 size_t clear_size)

551 {

552 int same = 1;

553 int i;

554

555 if (!clear_size)

556 return;

557

558 // Reduce to memset() if possible.

559 for (i = 0; i < clear_size; i++) {

560 if (clear[i] != clear[0]) {

561 same = 0;

562 break;

563 }

564 }

565 if (same)

566 clear_size = 1;

567

568 if (clear_size == 1) {

569 memset(dst, clear[0], dst_size);

570 } else {

571 if (clear_size > dst_size)

572 clear_size = dst_size;

573 memcpy(dst, clear, clear_size);

574 av_memcpy_backptr(dst + clear_size, clear_size, dst_size - clear_size);

575 }

576 }

577

578 // Maximum size in bytes of a plane element (usually a pixel, or multiple pixels

579 // if it's a subsampled packed format).

580 #define MAX_BLOCK_SIZE 32

581

582 int av_image_fill_black(uint8_t *dst_data[4], const ptrdiff_t dst_linesize[4],

583 enum AVPixelFormat pix_fmt, enum AVColorRange range,

584 int width, int height)

585 {

586 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);

587 int nb_planes = av_pix_fmt_count_planes(pix_fmt);

588 // A pixel or a group of pixels on each plane, with a value that represents black.

589 // Consider e.g. AV_PIX_FMT_UYVY422 for non-trivial cases.

590 uint8_t clear_block[4][MAX_BLOCK_SIZE] = {{0}}; // clear padding with 0

591 int clear_block_size[4] = {0};

592 ptrdiff_t plane_line_bytes[4] = {0};

593 int rgb, limited;

594 int plane, c;

595

596 if (!desc || nb_planes < 1 || nb_planes > 4 || desc->flags & AV_PIX_FMT_FLAG_HWACCEL)

597 return AVERROR(EINVAL);

598

599 rgb = !!(desc->flags & AV_PIX_FMT_FLAG_RGB);

600 limited = !rgb && range != AVCOL_RANGE_JPEG;

601

602 if (desc->flags & AV_PIX_FMT_FLAG_BITSTREAM) {

603 ptrdiff_t bytewidth = av_image_get_linesize(pix_fmt, width, 0);

604 uint8_t *data;

605 int mono = pix_fmt == AV_PIX_FMT_MONOWHITE || pix_fmt == AV_PIX_FMT_MONOBLACK;

606 int fill = pix_fmt == AV_PIX_FMT_MONOWHITE ? 0xFF : 0;

607 if (nb_planes != 1 || !(rgb || mono) || bytewidth < 1)

608 return AVERROR(EINVAL);

609

610 if (!dst_data)

611 return 0;

612

613 data = dst_data[0];

614

615 // (Bitstream + alpha will be handled incorrectly - it'll remain transparent.)

616 for (;height > 0; height--) {

617 memset(data, fill, bytewidth);

618 data += dst_linesize[0];

619 }

620 return 0;

621 }

622

623 for (c = 0; c < desc->nb_components; c++) {

624 const AVComponentDescriptor comp = desc->comp[c];

625

626 // We try to operate on entire non-subsampled pixel groups (for

627 // AV_PIX_FMT_UYVY422 this would mean two consecutive pixels).

628 clear_block_size[comp.plane] = FFMAX(clear_block_size[comp.plane], comp.step);

629

630 if (clear_block_size[comp.plane] > MAX_BLOCK_SIZE)

631 return AVERROR(EINVAL);

632 }

633

634 // Create a byte array for clearing 1 pixel (sometimes several pixels).

635 for (c = 0; c < desc->nb_components; c++) {

636 const AVComponentDescriptor comp = desc->comp[c];

637 // (Multiple pixels happen e.g. with AV_PIX_FMT_UYVY422.)

638 int w = clear_block_size[comp.plane] / comp.step;

639 uint8_t *c_data[4];

640 const int c_linesize[4] = {0};

641 uint16_t src_array[MAX_BLOCK_SIZE];

642 uint16_t src = 0;

643 int x;

644

645 if (comp.depth > 16)

646 return AVERROR(EINVAL);

647 if (!rgb && comp.depth < 8)

648 return AVERROR(EINVAL);

649 if (w < 1)

650 return AVERROR(EINVAL);

651

652 if (c == 0 && limited) {

653 src = 16 << (comp.depth - 8);

654 } else if ((c == 1 || c == 2) && !rgb) {

655 src = 128 << (comp.depth - 8);

656 } else if (c == 3) {

657 // (Assume even limited YUV uses full range alpha.)

658 src = (1 << comp.depth) - 1;

659 }

660

661 for (x = 0; x < w; x++)

662 src_array[x] = src;

663

664 for (x = 0; x < 4; x++)

665 c_data[x] = &clear_block[x][0];

666

667 av_write_image_line(src_array, c_data, c_linesize, desc, 0, 0, c, w);

668 }

669

670 for (plane = 0; plane < nb_planes; plane++) {

671 plane_line_bytes[plane] = av_image_get_linesize(pix_fmt, width, plane);

672 if (plane_line_bytes[plane] < 0)

673 return AVERROR(EINVAL);

674 }

675

676 if (!dst_data)

677 return 0;

678

679 for (plane = 0; plane < nb_planes; plane++) {

680 size_t bytewidth = plane_line_bytes[plane];

681 uint8_t *data = dst_data[plane];

682 int chroma_div = plane == 1 || plane == 2 ? desc->log2_chroma_h : 0;

683 int plane_h = ((height + ( 1 << chroma_div) - 1)) >> chroma_div;

684

685 for (; plane_h > 0; plane_h--) {

686 memset_bytes(data, bytewidth, &clear_block[plane][0], clear_block_size[plane]);

687 data += dst_linesize[plane];

688 }

689 }

690

691 return 0;

692 }

AVPixelFormat

Pixel format.

Definition: pixfmt.h:64

image_get_linesize

static int image_get_linesize(int width, int plane, int max_step, int max_step_comp, const AVPixFmtDescriptor *desc)

Definition: imgutils.c:54

const char * r

Definition: vf_curves.c:126

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

AV_WL32

#define AV_WL32(p, v)

Definition: intreadwrite.h:426

comp

static void comp(unsigned char *dst, ptrdiff_t dst_stride, unsigned char *src, ptrdiff_t src_stride, int add)

Definition: eamad.c:80

av_pix_fmt_desc_get

const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)

Definition: pixdesc.c:2888

rational.h

av_write_image_line

void av_write_image_line(const uint16_t *src, uint8_t *data[4], const int linesize[4], const AVPixFmtDescriptor *desc, int x, int y, int c, int w)

Definition: pixdesc.c:189

pixdesc.h

uint8_t w

Definition: llviddspenc.c:38

AVCOL_RANGE_JPEG

@ AVCOL_RANGE_JPEG

Full range content.

Definition: pixfmt.h:661

#define b

Definition: input.c:41

data

const char data[16]

Definition: mxf.c:146

AV_PIX_FMT_MONOWHITE

@ AV_PIX_FMT_MONOWHITE

Y , 1bpp, 0 is white, 1 is black, in each byte pixels are ordered from the msb to the lsb.

Definition: pixfmt.h:75

ImgUtils

Definition: imgutils.c:274

mathematics.h

FFMAX

#define FFMAX(a, b)

Definition: macros.h:47

av_malloc

#define av_malloc(s)

Definition: tableprint_vlc.h:30

av_image_copy_plane

void av_image_copy_plane(uint8_t *dst, int dst_linesize, const uint8_t *src, int src_linesize, int bytewidth, int height)

Copy image plane from src to dst.

Definition: imgutils.c:374

image_copy

static void image_copy(uint8_t *dst_data[4], const ptrdiff_t dst_linesizes[4], const uint8_t *src_data[4], const ptrdiff_t src_linesizes[4], enum AVPixelFormat pix_fmt, int width, int height, void(*copy_plane)(uint8_t *, ptrdiff_t, const uint8_t *, ptrdiff_t, ptrdiff_t, int))

Definition: imgutils.c:381

av_pix_fmt_count_planes

int av_pix_fmt_count_planes(enum AVPixelFormat pix_fmt)

Definition: pixdesc.c:2928

rgb

Definition: rpzaenc.c:59

ImgUtils::log_ctx

void * log_ctx

Definition: imgutils.c:277

AV_PIX_FMT_FLAG_HWACCEL

#define AV_PIX_FMT_FLAG_HWACCEL

Pixel format is an HW accelerated format.

Definition: pixdesc.h:128

av_image_fill_pointers

int av_image_fill_pointers(uint8_t *data[4], enum AVPixelFormat pix_fmt, int height, uint8_t *ptr, const int linesizes[4])

Fill plane data pointers for an image with pixel format pix_fmt and height height.

Definition: imgutils.c:145

AVRational::num

int num

Numerator.

Definition: rational.h:59

copy_plane

static void copy_plane(AVCodecContext *avctx, AVFrame *src, AVFrame *dst)

Definition: rasc.c:81

av_image_check_size2

int av_image_check_size2(unsigned int w, unsigned int h, int64_t max_pixels, enum AVPixelFormat pix_fmt, int log_offset, void *log_ctx)

Check if the given dimension of an image is valid, meaning that all bytes of a plane of an image with...

Definition: imgutils.c:289

ff_image_copy_plane_uc_from_x86

int ff_image_copy_plane_uc_from_x86(uint8_t *dst, ptrdiff_t dst_linesize, const uint8_t *src, ptrdiff_t src_linesize, ptrdiff_t bytewidth, int height)

Definition: imgutils_init.c:33

AV_PIX_FMT_BGR8

@ AV_PIX_FMT_BGR8

packed RGB 3:3:2, 8bpp, (msb)2B 3G 3R(lsb)

Definition: pixfmt.h:83

avassert.h

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:180

ImgUtils::class

const AVClass * class

Definition: imgutils.c:275

av_memcpy_backptr

void av_memcpy_backptr(uint8_t *dst, int back, int cnt)

Overlapping memcpy() implementation.

Definition: mem.c:445

width

#define width

av_image_fill_linesizes

int av_image_fill_linesizes(int linesizes[4], enum AVPixelFormat pix_fmt, int width)

Fill plane linesizes for an image with pixel format pix_fmt and width width.

Definition: imgutils.c:89

intreadwrite.h

#define s(width, name)

Definition: cbs_vp9.c:256

AV_CEIL_RSHIFT

#define AV_CEIL_RSHIFT(a, b)

Definition: common.h:50

const char * g

Definition: vf_curves.c:127

pix_fmt

static enum AVPixelFormat pix_fmt

Definition: demux_decode.c:41

ImgUtils::log_offset

int log_offset

Definition: imgutils.c:276

image_copy_plane

static void image_copy_plane(uint8_t *dst, ptrdiff_t dst_linesize, const uint8_t *src, ptrdiff_t src_linesize, ptrdiff_t bytewidth, int height)

Definition: imgutils.c:344

av_assert0

#define av_assert0(cond)

assert() equivalent, that is always enabled.

Definition: avassert.h:37

pointers

Undefined Behavior In the C some operations are like signed integer dereferencing freed pointers

Definition: undefined.txt:4

avpriv_set_systematic_pal2

int avpriv_set_systematic_pal2(uint32_t pal[256], enum AVPixelFormat pix_fmt)

Definition: imgutils.c:178

FFABS

#define FFABS(a)

Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...

Definition: common.h:64

LIBAVUTIL_VERSION_INT

#define LIBAVUTIL_VERSION_INT

Definition: version.h:85

AVClass

Describe the class of an AVClass context structure.

Definition: log.h:66

NULL

#define NULL

Definition: coverity.c:32

sizes

static const int sizes[][2]

Definition: img2dec.c:57

AVComponentDescriptor

Definition: pixdesc.h:30

MAX_BLOCK_SIZE

#define MAX_BLOCK_SIZE

Definition: imgutils.c:580

av_image_fill_plane_sizes

int av_image_fill_plane_sizes(size_t sizes[4], enum AVPixelFormat pix_fmt, int height, const ptrdiff_t linesizes[4])

Fill plane sizes for an image with pixel format pix_fmt and height height.

Definition: imgutils.c:111

AVRational

Rational number (pair of numerator and denominator).

Definition: rational.h:58

AV_PIX_FMT_MONOBLACK

@ AV_PIX_FMT_MONOBLACK

Y , 1bpp, 0 is black, 1 is white, in each byte pixels are ordered from the msb to the lsb.

Definition: pixfmt.h:76

av_default_item_name

const char * av_default_item_name(void *ptr)

Return the context name.

Definition: log.c:237

AV_RN32

#define AV_RN32(p)

Definition: intreadwrite.h:364

AV_PIX_FMT_RGB8

@ AV_PIX_FMT_RGB8

packed RGB 3:3:2, 8bpp, (msb)2R 3G 3B(lsb)

Definition: pixfmt.h:86

AV_PIX_FMT_GRAY8

@ AV_PIX_FMT_GRAY8

Y , 8bpp.

Definition: pixfmt.h:74

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

Definition: undefined.txt:32

av_image_fill_black

int av_image_fill_black(uint8_t *dst_data[4], const ptrdiff_t dst_linesize[4], enum AVPixelFormat pix_fmt, enum AVColorRange range, int width, int height)

Overwrite the image data with black.

Definition: imgutils.c:582

AV_PIX_FMT_BGR4_BYTE

@ AV_PIX_FMT_BGR4_BYTE

packed RGB 1:2:1, 8bpp, (msb)1B 2G 1R(lsb)

Definition: pixfmt.h:85

av_image_alloc

int av_image_alloc(uint8_t *pointers[4], int linesizes[4], int w, int h, enum AVPixelFormat pix_fmt, int align)

Allocate an image with size w and h and pixel format pix_fmt, and fill pointers and linesizes accordi...

Definition: imgutils.c:218

av_rescale_rnd

int64_t av_rescale_rnd(int64_t a, int64_t b, int64_t c, enum AVRounding rnd)

Rescale a 64-bit integer with specified rounding.

Definition: mathematics.c:58

memset_bytes

static void memset_bytes(uint8_t *dst, size_t dst_size, uint8_t *clear, size_t clear_size)

Definition: imgutils.c:549

av_image_fill_arrays

int av_image_fill_arrays(uint8_t *dst_data[4], int dst_linesize[4], const uint8_t *src, enum AVPixelFormat pix_fmt, int width, int height, int align)

Setup the data pointers and linesizes based on the specified image parameters and the provided array.

Definition: imgutils.c:446

AV_PIX_FMT_FLAG_RGB

#define AV_PIX_FMT_FLAG_RGB

The pixel format contains RGB-like data (as opposed to YUV/grayscale).

Definition: pixdesc.h:136

shift

static int shift(int a, int b)

Definition: bonk.c:257

AV_ROUND_ZERO

@ AV_ROUND_ZERO

Round toward zero.

Definition: mathematics.h:80

for

for(k=2;k<=8;++k)

Definition: h264pred_template.c:425

size

int size

Definition: twinvq_data.h:10344

AV_PIX_FMT_FLAG_BITSTREAM

#define AV_PIX_FMT_FLAG_BITSTREAM

All values of a component are bit-wise packed end to end.

Definition: pixdesc.h:124

align

static const uint8_t *BS_FUNC() align(BSCTX *bc)

Skip bits to a byte boundary.

Definition: bitstream_template.h:411

height

#define height

av_image_get_buffer_size

int av_image_get_buffer_size(enum AVPixelFormat pix_fmt, int width, int height, int align)

Return the size in bytes of the amount of data required to store an image with the given parameters.

Definition: imgutils.c:466

imgutils_internal.h

imgutils_class

static const AVClass imgutils_class

Definition: imgutils.c:280

av_image_get_linesize

int av_image_get_linesize(enum AVPixelFormat pix_fmt, int width, int plane)

Compute the size of an image line with format pix_fmt and width width for the plane plane.

Definition: imgutils.c:76

av_image_copy_uc_from

void av_image_copy_uc_from(uint8_t *dst_data[4], const ptrdiff_t dst_linesizes[4], const uint8_t *src_data[4], const ptrdiff_t src_linesizes[4], enum AVPixelFormat pix_fmt, int width, int height)

Copy image data located in uncacheable (e.g.

Definition: imgutils.c:438

log.h

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

Definition: cbs_h2645.c:269

internal.h

common.h

AV_PIX_FMT_RGB4_BYTE

@ AV_PIX_FMT_RGB4_BYTE

packed RGB 1:2:1, 8bpp, (msb)1R 2G 1B(lsb)

Definition: pixfmt.h:88

stride

#define stride

Definition: h264pred_template.c:537

ret

Definition: filter_design.txt:187

AVClass::class_name

const char * class_name

The name of the class; usually it is the same name as the context structure type to which the AVClass...

Definition: log.h:71

#define U(x)

Definition: vpx_arith.h:37

av_image_copy_plane_uc_from

void av_image_copy_plane_uc_from(uint8_t *dst, ptrdiff_t dst_linesize, const uint8_t *src, ptrdiff_t src_linesize, ptrdiff_t bytewidth, int height)

Copy image data located in uncacheable (e.g.

Definition: imgutils.c:359

av_image_copy

void av_image_copy(uint8_t *dst_data[4], int dst_linesizes[4], const uint8_t *src_data[4], const int src_linesizes[4], enum AVPixelFormat pix_fmt, int width, int height)

Copy image in src_data to dst_data.

Definition: imgutils.c:422

AVRational::den

int den

Denominator.

Definition: rational.h:60

AV_PIX_FMT_NONE

@ AV_PIX_FMT_NONE

Definition: pixfmt.h:65

AVPixFmtDescriptor::comp

AVComponentDescriptor comp[4]

Parameters that describe how pixels are packed.

Definition: pixdesc.h:105

av_image_fill_max_pixsteps

void av_image_fill_max_pixsteps(int max_pixsteps[4], int max_pixstep_comps[4], const AVPixFmtDescriptor *pixdesc)

Compute the max pixel step for each plane of an image with a format described by pixdesc.

Definition: imgutils.c:35

desc

const char * desc

Definition: libsvtav1.c:83

d32

const uint8_t * d32

Definition: yuv2rgb.c:501

AVPixFmtDescriptor

Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...

Definition: pixdesc.h:69

av_free

#define av_free(p)

Definition: tableprint_vlc.h:33

av_image_copy_to_buffer

int av_image_copy_to_buffer(uint8_t *dst, int dst_size, const uint8_t *const src_data[4], const int src_linesize[4], enum AVPixelFormat pix_fmt, int width, int height, int align)

Copy image data from an image into a buffer.

Definition: imgutils.c:501

FFALIGN

#define FFALIGN(x, a)

Definition: macros.h:78

src

INIT_CLIP pixel * src

Definition: h264pred_template.c:418

imgutils.h

rgb

static const SheerTable rgb[2]

Definition: sheervideodata.h:32