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_pointers(uint8_t *data[4], enum AVPixelFormat pix_fmt, int height,

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

113 {

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

115

116 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);

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

118

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

120 return AVERROR(EINVAL);

121

122 data[0] = ptr;

123 if (linesizes[0] > (INT_MAX - 1024) / height)

124 return AVERROR(EINVAL);

125 size[0] = linesizes[0] * height;

126

127 if (desc->flags & AV_PIX_FMT_FLAG_PAL ||

128 desc->flags & FF_PSEUDOPAL) {

129 data[1] = ptr + size[0]; /* palette is stored here as 256 32 bits words */

130 return size[0] + 256 * 4;

131 }

132

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

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

135

136 total_size = size[0];

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

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

139 data[i] = data[i-1] + size[i-1];

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

141 if (linesizes[i] > INT_MAX / h)

142 return AVERROR(EINVAL);

143 size[i] = h * linesizes[i];

144 if (total_size > INT_MAX - size[i])

145 return AVERROR(EINVAL);

146 total_size += size[i];

147 }

148

149 return total_size;

150 }

151

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

153 {

154 int i;

155

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

157 int r, g, b;

158

159 switch (pix_fmt) {

160 case AV_PIX_FMT_RGB8:

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

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

163 b = (i&3 )*85;

164 break;

165 case AV_PIX_FMT_BGR8:

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

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

168 r = (i&7 )*36;

169 break;

170 case AV_PIX_FMT_RGB4_BYTE:

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

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

173 b = (i&1 )*255;

174 break;

175 case AV_PIX_FMT_BGR4_BYTE:

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

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

178 r = (i&1 )*255;

179 break;

180 case AV_PIX_FMT_GRAY8:

181 r = b = g = i;

182 break;

183 default:

184 return AVERROR(EINVAL);

185 }

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

187 }

188

189 return 0;

190 }

191

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

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

194 {

195 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);

196 int i, ret;

197 uint8_t *buf;

198

199 if (!desc)

200 return AVERROR(EINVAL);

201

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

203 return ret;

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

205 return ret;

206

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

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

209

210 if ((ret = av_image_fill_pointers(pointers, pix_fmt, h, NULL, linesizes)) < 0)

211 return ret;

212 buf = av_malloc(ret + align);

213 if (!buf)

214 return AVERROR(ENOMEM);

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

216 av_free(buf);

217 return ret;

218 }

219 if (desc->flags & AV_PIX_FMT_FLAG_PAL || (desc->flags & FF_PSEUDOPAL && pointers[1])) {

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

221 if (align < 4) {

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

223 return AVERROR(EINVAL);

224 }

225 }

226

227 if ((desc->flags & AV_PIX_FMT_FLAG_PAL ||

228 desc->flags & FF_PSEUDOPAL) && pointers[1] &&

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

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

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

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

233 }

234

235 return ret;

236 }

237

238 typedef struct ImgUtils {

239 const AVClass *class;

240 int log_offset;

241 void *log_ctx;

242 } ImgUtils;

243

244 static const AVClass imgutils_class = {

245 .class_name = "IMGUTILS",

246 .item_name = av_default_item_name,

247 .option = NULL,

248 .version = LIBAVUTIL_VERSION_INT,

249 .log_level_offset_offset = offsetof(ImgUtils, log_offset),

250 .parent_log_context_offset = offsetof(ImgUtils, log_ctx),

251 };

252

253 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)

254 {

255 ImgUtils imgutils = {

256 .class = &imgutils_class,

257 .log_offset = log_offset,

258 .log_ctx = log_ctx,

259 };

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

261 if (stride <= 0)

262 stride = 8LL*w;

263 stride += 128*8;

264

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

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

267 return AVERROR(EINVAL);

268 }

269

270 if (max_pixels < INT64_MAX) {

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

272 av_log(&imgutils, AV_LOG_ERROR,

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

274 w, h, max_pixels);

275 return AVERROR(EINVAL);

276 }

277 }

278

279 return 0;

280 }

281

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

283 {

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

285 }

286

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

288 {

289 int64_t scaled_dim;

290

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

292 return AVERROR(EINVAL);

293

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

295 return 0;

296

297 if (sar.num < sar.den)

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

299 else

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

301

302 if (scaled_dim > 0)

303 return 0;

304

305 return AVERROR(EINVAL);

306 }

307

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

309 const uint8_t *src, ptrdiff_t src_linesize,

310 ptrdiff_t bytewidth, int height)

311 {

312 if (!dst || !src)

313 return;

314 av_assert0(abs(src_linesize) >= bytewidth);

315 av_assert0(abs(dst_linesize) >= bytewidth);

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

317 memcpy(dst, src, bytewidth);

318 dst += dst_linesize;

319 src += src_linesize;

320 }

321 }

322

323 static void image_copy_plane_uc_from(uint8_t *dst, ptrdiff_t dst_linesize,

324 const uint8_t *src, ptrdiff_t src_linesize,

325 ptrdiff_t bytewidth, int height)

326 {

327 int ret = -1;

328

329 #if ARCH_X86

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

331 bytewidth, height);

332 #endif

333

334 if (ret < 0)

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

336 }

337

338 void av_image_copy_plane(uint8_t *dst, int dst_linesize,

339 const uint8_t *src, int src_linesize,

340 int bytewidth, int height)

341 {

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

343 }

344

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

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

347 enum AVPixelFormat pix_fmt, int width, int height,

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

349 ptrdiff_t, ptrdiff_t, int))

350 {

351 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);

352

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

354 return;

355

356 if (desc->flags & AV_PIX_FMT_FLAG_PAL ||

357 desc->flags & FF_PSEUDOPAL) {

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

359 src_data[0], src_linesizes[0],

360 width, height);

361 /* copy the palette */

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

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

364 } else {

365 int i, planes_nb = 0;

366

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

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

369

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

371 int h = height;

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

373 if (bwidth < 0) {

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

375 return;

376 }

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

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

379 }

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

381 src_data[i], src_linesizes[i],

382 bwidth, h);

383 }

384 }

385 }

386

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

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

389 enum AVPixelFormat pix_fmt, int width, int height)

390 {

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

392 int i;

393

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

395 dst_linesizes1[i] = dst_linesizes[i];

396 src_linesizes1[i] = src_linesizes[i];

397 }

398

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

400 width, height, image_copy_plane);

401 }

402

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

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

405 enum AVPixelFormat pix_fmt, int width, int height)

406 {

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

408 width, height, image_copy_plane_uc_from);

409 }

410

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

412 const uint8_t *src, enum AVPixelFormat pix_fmt,

413 int width, int height, int align)

414 {

415 int ret, i;

416

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

418 if (ret < 0)

419 return ret;

420

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

422 if (ret < 0)

423 return ret;

424

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

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

427

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

429 }

430

431 int av_image_get_buffer_size(enum AVPixelFormat pix_fmt,

432 int width, int height, int align)

433 {

434 uint8_t *data[4];

435 int linesize[4];

436 int ret;

437 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);

438 if (!desc)

439 return AVERROR(EINVAL);

440

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

442 if (ret < 0)

443 return ret;

444

445 // do not include palette for these pseudo-paletted formats

446 if (desc->flags & FF_PSEUDOPAL)

447 return FFALIGN(width, align) * height;

448

449 return av_image_fill_arrays(data, linesize, NULL, pix_fmt,

450 width, height, align);

451 }

452

453 int av_image_copy_to_buffer(uint8_t *dst, int dst_size,

454 const uint8_t * const src_data[4],

455 const int src_linesize[4],

456 enum AVPixelFormat pix_fmt,

457 int width, int height, int align)

458 {

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

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

461 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);

462 int ret;

463

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

465 return AVERROR(EINVAL);

466

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

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

469

470 nb_planes++;

471

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

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

474

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

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

477 const uint8_t *src = src_data[i];

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

479

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

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

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

483 src += src_linesize[i];

484 }

485 }

486

487 if (desc->flags & AV_PIX_FMT_FLAG_PAL) {

488 uint32_t *d32 = (uint32_t *)dst;

489

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

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

492 }

493

494 return size;

495 }

496

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

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

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

500 // of the clear data only.

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

502 size_t clear_size)

503 {

504 size_t pos = 0;

505 int same = 1;

506 int i;

507

508 if (!clear_size)

509 return;

510

511 // Reduce to memset() if possible.

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

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

514 same = 0;

515 break;

516 }

517 }

518 if (same)

519 clear_size = 1;

520

521 if (clear_size == 1) {

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

523 dst_size = 0;

524 } else if (clear_size == 2) {

525 uint16_t val = AV_RN16(clear);

526 for (; dst_size >= 2; dst_size -= 2) {

527 AV_WN16(dst, val);

528 dst += 2;

529 }

530 } else if (clear_size == 4) {

531 uint32_t val = AV_RN32(clear);

532 for (; dst_size >= 4; dst_size -= 4) {

533 AV_WN32(dst, val);

534 dst += 4;

535 }

536 } else if (clear_size == 8) {

537 uint32_t val = AV_RN64(clear);

538 for (; dst_size >= 8; dst_size -= 8) {

539 AV_WN64(dst, val);

540 dst += 8;

541 }

542 }

543

544 for (; dst_size; dst_size--)

545 *dst++ = clear[pos++ % clear_size];

546 }

547

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

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

550 #define MAX_BLOCK_SIZE 32

551

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

553 enum AVPixelFormat pix_fmt, enum AVColorRange range,

554 int width, int height)

555 {

556 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);

557 int nb_planes = av_pix_fmt_count_planes(pix_fmt);

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

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

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

561 int clear_block_size[4] = {0};

562 ptrdiff_t plane_line_bytes[4] = {0};

563 int rgb, limited;

564 int plane, c;

565

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

567 return AVERROR(EINVAL);

568

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

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

571

572 if (desc->flags & AV_PIX_FMT_FLAG_BITSTREAM) {

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

574 uint8_t *data;

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

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

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

578 return AVERROR(EINVAL);

579

580 if (!dst_data)

581 return 0;

582

583 data = dst_data[0];

584

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

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

587 memset(data, fill, bytewidth);

588 data += dst_linesize[0];

589 }

590 return 0;

591 }

592

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

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

595

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

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

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

599

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

601 return AVERROR(EINVAL);

602 }

603

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

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

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

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

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

609 uint8_t *c_data[4];

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

611 uint16_t src_array[MAX_BLOCK_SIZE];

612 uint16_t src = 0;

613 int x;

614

615 if (comp.depth > 16)

616 return AVERROR(EINVAL);

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

618 return AVERROR(EINVAL);

619 if (w < 1)

620 return AVERROR(EINVAL);

621

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

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

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

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

626 } else if (c == 3) {

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

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

629 }

630

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

632 src_array[x] = src;

633

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

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

636

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

638 }

639

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

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

642 if (plane_line_bytes[plane] < 0)

643 return AVERROR(EINVAL);

644 }

645

646 if (!dst_data)

647 return 0;

648

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

650 size_t bytewidth = plane_line_bytes[plane];

651 uint8_t *data = dst_data[plane];

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

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

654

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

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

657 data += dst_linesize[plane];

658 }

659 }

660

661 return 0;

662 }

AV_PIX_FMT_FLAG_PAL

#define AV_PIX_FMT_FLAG_PAL

Pixel format has a palette in data[1], values are indexes in this palette.

Definition: pixdesc.h:132

plane

int plane

Definition: avisynth_c.h:422

AVComponentDescriptor::plane

int plane

Which of the 4 planes contains the component.

Definition: pixdesc.h:35

NULL

#define NULL

Definition: coverity.c:32

val

const char const char void * val

Definition: avisynth_c.h:771

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

const char * s

Definition: avisynth_c.h:768

pix_fmt

static enum AVPixelFormat pix_fmt

Definition: demuxing_decoding.c:40

shift

static int shift(int a, int b)

Definition: sonic.c:82

av_pix_fmt_desc_get

const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)

Definition: pixdesc.c:2363

AV_PIX_FMT_NONE

Definition: pixfmt.h:61

Definition: vp9dsp_template.c:2038

data

ptrdiff_t const GLvoid * data

Definition: opengl_enc.c:101

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

imgutils.h

misc image utilities

av_pix_fmt_count_planes

int av_pix_fmt_count_planes(enum AVPixelFormat pix_fmt)

Definition: pixdesc.c:2403

LIBAVUTIL_VERSION_INT

#define LIBAVUTIL_VERSION_INT

Definition: version.h:85

ImgUtils

Definition: imgutils.c:238

const char * g

Definition: vf_curves.c:112

desc

const char * desc

Definition: nvenc.c:65

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

AVRational::num

int num

Numerator.

Definition: rational.h:59

imgutils_class

static const AVClass imgutils_class

Definition: imgutils.c:244

const char * b

Definition: vf_curves.c:113

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

av_default_item_name

const char * av_default_item_name(void *ptr)

Return the context name.

Definition: log.c:191

memset_bytes

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

Definition: imgutils.c:501

src

#define src

Definition: vp8dsp.c:254

AVPixFmtDescriptor::log2_chroma_w

uint8_t log2_chroma_w

Amount to shift the luma width right to find the chroma width.

Definition: pixdesc.h:92

AV_PIX_FMT_BGR4_BYTE

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

Definition: pixfmt.h:81

mathematics.h

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

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

av_assert0

#define av_assert0(cond)

assert() equivalent, that is always enabled.

Definition: avassert.h:37

AVPixFmtDescriptor::comp

AVComponentDescriptor comp[4]

Parameters that describe how pixels are packed.

Definition: pixdesc.h:117

uint8_t

Definition: audio_convert.c:194

av_malloc

#define av_malloc(s)

Definition: tableprint_vlc.h:31

avpriv_set_systematic_pal2

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

Definition: imgutils.c:152

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)

Write the values from src to the pixel format component c of an image line.

Definition: pixdesc.c:82

ImgUtils::log_ctx

void * log_ctx

Definition: imgutils.c:241

av_image_check_sar

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

Check if the given sample aspect ratio of an image is valid.

Definition: imgutils.c:287

height

#define height

MAX_BLOCK_SIZE

#define MAX_BLOCK_SIZE

Definition: imgutils.c:550

AVColorRange

MPEG vs JPEG YUV range.

Definition: pixfmt.h:496

size

ptrdiff_t size

Definition: opengl_enc.c:101

AVComponentDescriptor

Definition: pixdesc.h:31

FFALIGN

#define FFALIGN(x, a)

Definition: macros.h:48

av_log

#define av_log(a,...)

Definition: tableprint_vlc.h:28

#define U(x)

Definition: vp56_arith.h:37

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

imgutils_internal.h

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:176

AVPixFmtDescriptor::log2_chroma_h

uint8_t log2_chroma_h

Amount to shift the luma height right to find the chroma height.

Definition: pixdesc.h:101

AVERROR

#define AVERROR(e)

Definition: error.h:43

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

image_copy_plane_uc_from

static void 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)

Definition: imgutils.c:323

const char * r

Definition: vf_curves.c:111

width

uint16_t width

Definition: gdv.c:47

AV_PIX_FMT_FLAG_HWACCEL

#define AV_PIX_FMT_FLAG_HWACCEL

Pixel format is an HW accelerated format.

Definition: pixdesc.h:140

avassert.h

simple assert() macros that are a bit more flexible than ISO C assert().

FFMAX

#define FFMAX(a, b)

Definition: common.h:94

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

internal.h

common internal API header

AVPixFmtDescriptor::flags

uint64_t flags

Combination of AV_PIX_FMT_FLAG_...

Definition: pixdesc.h:106

av_image_check_size

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

Check if the given dimension of an image is valid, meaning that all bytes of the image can be address...

Definition: imgutils.c:282

AVPixFmtDescriptor::nb_components

uint8_t nb_components

The number of components each pixel has, (1-4)

Definition: pixdesc.h:83

pixdesc.h

AV_PIX_FMT_RGB4_BYTE

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

Definition: pixfmt.h:84

AV_ROUND_ZERO

Round toward zero.

Definition: mathematics.h:80

intreadwrite.h

uint8_t w

Definition: llviddspenc.c:38

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

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

AVCOL_RANGE_JPEG

the normal 2^n-1 "JPEG" YUV ranges

Definition: pixfmt.h:499

comp

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

Definition: eamad.c:83

ImgUtils::class

const AVClass * class

Definition: imgutils.c:239

align

const AVS_VideoInfo int align

Definition: avisynth_c.h:795

ImgUtils::log_offset

int log_offset

Definition: imgutils.c:240

AV_PIX_FMT_BGR8

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

Definition: pixfmt.h:79

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

AVPixFmtDescriptor

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

Definition: pixdesc.h:81

AV_RN16

#define AV_RN16(p)

Definition: intreadwrite.h:360

buf

void * buf

Definition: avisynth_c.h:690

AVClass

Describe the class of an AVClass context structure.

Definition: log.h:67

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

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

AVRational

Rational number (pair of numerator and denominator).

Definition: rational.h:58

d32

const uint8_t * d32

Definition: yuv2rgb.c:501

AV_RN32

#define AV_RN32(p)

Definition: intreadwrite.h:364

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

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

stride

GLint GLenum GLboolean GLsizei stride

Definition: opengl_enc.c:105

AV_PIX_FMT_GRAY8

Y , 8bpp.

Definition: pixfmt.h:70

common.h

common internal and external API header

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

rational.h

Utilties for rational number calculation.

AV_WN32

#define AV_WN32(p, v)

Definition: intreadwrite.h:376

static double c[64]

Definition: vsrc_mptestsrc.c:87

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

AV_PIX_FMT_RGB8

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

Definition: pixfmt.h:82

AVRational::den

int den

Denominator.

Definition: rational.h:60

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

FF_PSEUDOPAL

#define FF_PSEUDOPAL

Definition: internal.h:367

av_free

#define av_free(p)

Definition: tableprint_vlc.h:34

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

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

log.h

AV_RN64

#define AV_RN64(p)

Definition: intreadwrite.h:368

AV_WN16

#define AV_WN16(p, v)

Definition: intreadwrite.h:372

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

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

AVComponentDescriptor::depth

int depth

Number of bits in the component.

Definition: pixdesc.h:58

AVPixelFormat

Pixel format.

Definition: pixfmt.h:60

for

for(j=16;j >0;--j)

Definition: h264pred_template.c:469

AVComponentDescriptor::step