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 "internal.h"

28 #include "intreadwrite.h"

29 #include "log.h"

30 #include "mathematics.h"

31 #include "pixdesc.h"

32 #include "rational.h"

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

35 const AVPixFmtDescriptor *pixdesc)

36 {

37 int i;

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

39 if (max_pixstep_comps)

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

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

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

44 if ((comp->step_minus1+1) > max_pixsteps[comp->plane]) {

45 max_pixsteps[comp->plane] = comp->step_minus1+1;

46 if (max_pixstep_comps)

47 max_pixstep_comps[comp->plane] = i;

48 }

49 }

50 }

52 static inline

53 int image_get_linesize(int width, int plane,

54 int max_step, int max_step_comp,

55 const AVPixFmtDescriptor *desc)

56 {

57 int s, shifted_w, linesize;

59 if (!desc)

60 return AVERROR(EINVAL);

62 if (width < 0)

63 return AVERROR(EINVAL);

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

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

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

67 return AVERROR(EINVAL);

68 linesize = max_step * shifted_w;

70 if (desc->flags & AV_PIX_FMT_FLAG_BITSTREAM)

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

72 return linesize;

73 }

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

76 {

77 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);

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

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

81 if ((unsigned)pix_fmt >= AV_PIX_FMT_NB || desc->flags & AV_PIX_FMT_FLAG_HWACCEL)

82 return AVERROR(EINVAL);

84 av_image_fill_max_pixsteps(max_step, max_step_comp, desc);

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

86 }

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

89 {

90 int i, ret;

91 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);

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

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

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

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

98 return AVERROR(EINVAL);

100 av_image_fill_max_pixsteps(max_step, max_step_comp, desc);

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

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

103 return ret;

104 linesizes[i] = ret;

105 }

106

107 return 0;

108 }

109

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

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

112 {

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

114

115 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);

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

117

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

119 return AVERROR(EINVAL);

120

121 data[0] = ptr;

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

123 return AVERROR(EINVAL);

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

125

126 if (desc->flags & AV_PIX_FMT_FLAG_PAL ||

127 desc->flags & AV_PIX_FMT_FLAG_PSEUDOPAL) {

128 size[0] = (size[0] + 3) & ~3;

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 & AV_PIX_FMT_FLAG_PSEUDOPAL)

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

221

222 return ret;

223 }

224

225 typedef struct ImgUtils {

226 const AVClass *class;

227 int log_offset;

228 void *log_ctx;

229 } ImgUtils;

230

231 static const AVClass imgutils_class = { "IMGUTILS", av_default_item_name, NULL, LIBAVUTIL_VERSION_INT, offsetof(ImgUtils, log_offset), offsetof(ImgUtils, log_ctx) };

232

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

234 {

235 ImgUtils imgutils = { &imgutils_class, log_offset, log_ctx };

236

237 if ((int)w>0 && (int)h>0 && (w+128)*(uint64_t)(h+128) < INT_MAX/8)

238 return 0;

239

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

241 return AVERROR(EINVAL);

242 }

243

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

245 {

246 int64_t scaled_dim;

247

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

249 return AVERROR(EINVAL);

250

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

252 return 0;

253

254 if (sar.num < sar.den)

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

256 else

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

258

259 if (scaled_dim > 0)

260 return 0;

261

262 return AVERROR(EINVAL);

263 }

264

265 void av_image_copy_plane(uint8_t *dst, int dst_linesize,

266 const uint8_t *src, int src_linesize,

267 int bytewidth, int height)

268 {

269 if (!dst || !src)

270 return;

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

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

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

274 memcpy(dst, src, bytewidth);

275 dst += dst_linesize;

276 src += src_linesize;

277 }

278 }

279

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

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

282 enum AVPixelFormat pix_fmt, int width, int height)

283 {

284 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);

285

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

287 return;

288

289 if (desc->flags & AV_PIX_FMT_FLAG_PAL ||

290 desc->flags & AV_PIX_FMT_FLAG_PSEUDOPAL) {

291 av_image_copy_plane(dst_data[0], dst_linesizes[0],

292 src_data[0], src_linesizes[0],

293 width, height);

294 /* copy the palette */

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

296 } else {

297 int i, planes_nb = 0;

298

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

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

301

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

303 int h = height;

304 int bwidth = av_image_get_linesize(pix_fmt, width, i);

305 if (bwidth < 0) {

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

307 return;

308 }

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

310 h = FF_CEIL_RSHIFT(height, desc->log2_chroma_h);

311 }

312 av_image_copy_plane(dst_data[i], dst_linesizes[i],

313 src_data[i], src_linesizes[i],

314 bwidth, h);

315 }

316 }

317 }

318

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

320 const uint8_t *src, enum AVPixelFormat pix_fmt,

321 int width, int height, int align)

322 {

323 int ret, i;

324

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

326 if (ret < 0)

327 return ret;

328

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

330 if (ret < 0)

331 return ret;

332

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

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

335

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

337 }

338

339 int av_image_get_buffer_size(enum AVPixelFormat pix_fmt,

340 int width, int height, int align)

341 {

342 uint8_t *data[4];

343 int linesize[4];

344 int ret;

345 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);

346 if (!desc)

347 return AVERROR(EINVAL);

348

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

350 if (ret < 0)

351 return ret;

352

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

354 if (desc->flags & AV_PIX_FMT_FLAG_PSEUDOPAL)

355 return width * height;

356

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

358 width, height, align);

359 }

360

361 int av_image_copy_to_buffer(uint8_t *dst, int dst_size,

362 const uint8_t * const src_data[4],

363 const int src_linesize[4],

364 enum AVPixelFormat pix_fmt,

365 int width, int height, int align)

366 {

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

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

369 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);

370

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

372 return AVERROR(EINVAL);

373

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

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

376

377 nb_planes++;

378

379 av_image_fill_linesizes(linesize, pix_fmt, width);

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

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

382 const uint8_t *src = src_data[i];

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

384

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

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

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

388 src += src_linesize[i];

389 }

390 }

391

392 if (desc->flags & AV_PIX_FMT_FLAG_PAL) {

393 uint32_t *d32 = (uint32_t *)(((size_t)dst + 3) & ~3);

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

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

396 }

397

398 return size;

399 }

Generated on Sun Mar 8 2015 02:35:14 for FFmpeg by doxygen 1.8.2