FFmpeg: libavutil/frame.c Source File

FFmpeg

[フレーム]

libavutil

frame.c

Go to the documentation of this file.

1 /*

2 *

3 * This file is part of FFmpeg.

4 *

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

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

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

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

9 *

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

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

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

13 * Lesser General Public License for more details.

14 *

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

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

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

18 */

20 #include "channel_layout.h"

21 #include "avassert.h"

22 #include "buffer.h"

23 #include "common.h"

24 #include "dict.h"

25 #include "frame.h"

26 #include "imgutils.h"

27 #include "mem.h"

28 #include "samplefmt.h"

30 #define MAKE_ACCESSORS(str, name, type, field) \

31 type av_##name##_get_##field(const str *s) { return s->field; } \

32 void av_##name##_set_##field(str *s, type v) { s->field = v; }

34 MAKE_ACCESSORS(AVFrame, frame, int64_t, best_effort_timestamp)

35 MAKE_ACCESSORS(AVFrame, frame, int64_t, pkt_duration)

36 MAKE_ACCESSORS(AVFrame, frame, int64_t, pkt_pos)

37 MAKE_ACCESSORS(AVFrame, frame, int64_t, channel_layout)

38 MAKE_ACCESSORS(AVFrame, frame, int, channels)

39 MAKE_ACCESSORS(AVFrame, frame, int, sample_rate)

40 MAKE_ACCESSORS(AVFrame, frame, AVDictionary *, metadata)

41 MAKE_ACCESSORS(AVFrame, frame, int, decode_error_flags)

42 MAKE_ACCESSORS(AVFrame, frame, int, pkt_size)

44 #define CHECK_CHANNELS_CONSISTENCY(frame) \

45 av_assert2(!(frame)->channel_layout || \

46 (frame)->channels == \

47 av_get_channel_layout_nb_channels((frame)->channel_layout))

49 AVDictionary **avpriv_frame_get_metadatap(AVFrame *frame) {return &frame->metadata;};

51 int av_frame_set_qp_table(AVFrame *f, AVBufferRef *buf, int stride, int qp_type)

52 {

53 av_buffer_unref(&f->qp_table_buf);

55 f->qp_table_buf = buf;

57 f->qscale_table = buf->data;

58 f->qstride = stride;

59 f->qscale_type = qp_type;

61 return 0;

62 }

64 int8_t *av_frame_get_qp_table(AVFrame *f, int *stride, int *type)

65 {

66 *stride = f->qstride;

67 *type = f->qscale_type;

69 if (!f->qp_table_buf)

70 return NULL;

72 return f->qp_table_buf->data;

73 }

75 static void get_frame_defaults(AVFrame *frame)

76 {

77 if (frame->extended_data != frame->data)

78 av_freep(&frame->extended_data);

80 memset(frame, 0, sizeof(*frame));

82 frame->pts =

83 frame->pkt_dts =

84 frame->pkt_pts = AV_NOPTS_VALUE;

85 av_frame_set_best_effort_timestamp(frame, AV_NOPTS_VALUE);

86 av_frame_set_pkt_duration (frame, 0);

87 av_frame_set_pkt_pos (frame, -1);

88 av_frame_set_pkt_size (frame, -1);

89 frame->key_frame = 1;

90 frame->sample_aspect_ratio = (AVRational){ 0, 1 };

91 frame->format = -1; /* unknown */

92 frame->extended_data = frame->data;

93 }

95 AVFrame *av_frame_alloc(void)

96 {

97 AVFrame *frame = av_mallocz(sizeof(*frame));

99 if (!frame)

100 return NULL;

101

102 frame->extended_data = NULL;

103 get_frame_defaults(frame);

104

105 return frame;

106 }

107

108 void av_frame_free(AVFrame **frame)

109 {

110 if (!frame || !*frame)

111 return;

112

113 av_frame_unref(*frame);

114 av_freep(frame);

115 }

116

117 static int get_video_buffer(AVFrame *frame, int align)

118 {

119 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(frame->format);

120 int ret, i;

121

122 if (!desc)

123 return AVERROR(EINVAL);

124

125 if ((ret = av_image_check_size(frame->width, frame->height, 0, NULL)) < 0)

126 return ret;

127

128 if (!frame->linesize[0]) {

129 for(i=1; i<=align; i+=i) {

130 ret = av_image_fill_linesizes(frame->linesize, frame->format,

131 FFALIGN(frame->width, i));

132 if (ret < 0)

133 return ret;

134 if (!(frame->linesize[0] & (align-1)))

135 break;

136 }

137

138 for (i = 0; i < 4 && frame->linesize[i]; i++)

139 frame->linesize[i] = FFALIGN(frame->linesize[i], align);

140 }

141

142 for (i = 0; i < 4 && frame->linesize[i]; i++) {

143 int h = FFALIGN(frame->height, 32);

144 if (i == 1 || i == 2)

145 h = FF_CEIL_RSHIFT(h, desc->log2_chroma_h);

146

147 frame->buf[i] = av_buffer_alloc(frame->linesize[i] * h + 16);

148 if (!frame->buf[i])

149 goto fail;

150

151 frame->data[i] = frame->buf[i]->data;

152 }

153 if (desc->flags & AV_PIX_FMT_FLAG_PAL || desc->flags & AV_PIX_FMT_FLAG_PSEUDOPAL) {

154 av_buffer_unref(&frame->buf[1]);

155 frame->buf[1] = av_buffer_alloc(1024);

156 if (!frame->buf[1])

157 goto fail;

158 frame->data[1] = frame->buf[1]->data;

159 }

160

161 frame->extended_data = frame->data;

162

163 return 0;

164 fail:

165 av_frame_unref(frame);

166 return AVERROR(ENOMEM);

167 }

168

169 static int get_audio_buffer(AVFrame *frame, int align)

170 {

171 int channels = frame->channels;

172 int planar = av_sample_fmt_is_planar(frame->format);

173 int planes = planar ? channels : 1;

174 int ret, i;

175

176 CHECK_CHANNELS_CONSISTENCY(frame);

177 if (!frame->linesize[0]) {

178 ret = av_samples_get_buffer_size(&frame->linesize[0], channels,

179 frame->nb_samples, frame->format,

180 align);

181 if (ret < 0)

182 return ret;

183 }

184

185 if (planes > AV_NUM_DATA_POINTERS) {

186 frame->extended_data = av_mallocz(planes *

187 sizeof(*frame->extended_data));

188 frame->extended_buf = av_mallocz((planes - AV_NUM_DATA_POINTERS) *

189 sizeof(*frame->extended_buf));

190 if (!frame->extended_data || !frame->extended_buf) {

191 av_freep(&frame->extended_data);

192 av_freep(&frame->extended_buf);

193 return AVERROR(ENOMEM);

194 }

195 frame->nb_extended_buf = planes - AV_NUM_DATA_POINTERS;

196 } else

197 frame->extended_data = frame->data;

198

199 for (i = 0; i < FFMIN(planes, AV_NUM_DATA_POINTERS); i++) {

200 frame->buf[i] = av_buffer_alloc(frame->linesize[0]);

201 if (!frame->buf[i]) {

202 av_frame_unref(frame);

203 return AVERROR(ENOMEM);

204 }

205 frame->extended_data[i] = frame->data[i] = frame->buf[i]->data;

206 }

207 for (i = 0; i < planes - AV_NUM_DATA_POINTERS; i++) {

208 frame->extended_buf[i] = av_buffer_alloc(frame->linesize[0]);

209 if (!frame->extended_buf[i]) {

210 av_frame_unref(frame);

211 return AVERROR(ENOMEM);

212 }

213 frame->extended_data[i + AV_NUM_DATA_POINTERS] = frame->extended_buf[i]->data;

214 }

215 return 0;

216

217 }

218

219 int av_frame_get_buffer(AVFrame *frame, int align)

220 {

221 if (frame->format < 0)

222 return AVERROR(EINVAL);

223

224 if (frame->width > 0 && frame->height > 0)

225 return get_video_buffer(frame, align);

226 else if (frame->nb_samples > 0 && frame->channel_layout)

227 return get_audio_buffer(frame, align);

228

229 return AVERROR(EINVAL);

230 }

231

232 int av_frame_ref(AVFrame *dst, AVFrame *src)

233 {

234 int i, ret = 0;

235

236 dst->format = src->format;

237 dst->width = src->width;

238 dst->height = src->height;

239 dst->channels = src->channels;

240 dst->channel_layout = src->channel_layout;

241 dst->nb_samples = src->nb_samples;

242

243 ret = av_frame_copy_props(dst, src);

244 if (ret < 0)

245 return ret;

246

247 /* duplicate the frame data if it's not refcounted */

248 if (!src->buf[0]) {

249 ret = av_frame_get_buffer(dst, 32);

250 if (ret < 0)

251 return ret;

252

253 if (src->nb_samples) {

254 int ch = src->channels;

255 CHECK_CHANNELS_CONSISTENCY(src);

256 av_samples_copy(dst->extended_data, src->extended_data, 0, 0,

257 dst->nb_samples, ch, dst->format);

258 } else {

259 av_image_copy(dst->data, dst->linesize, src->data, src->linesize,

260 dst->format, dst->width, dst->height);

261 }

262 return 0;

263 }

264

265 /* ref the buffers */

266 for (i = 0; i < FF_ARRAY_ELEMS(src->buf); i++) {

267 if (!src->buf[i])

268 continue;

269 dst->buf[i] = av_buffer_ref(src->buf[i]);

270 if (!dst->buf[i]) {

271 ret = AVERROR(ENOMEM);

272 goto fail;

273 }

274 }

275

276 if (src->extended_buf) {

277 dst->extended_buf = av_mallocz(sizeof(*dst->extended_buf) *

278 src->nb_extended_buf);

279 if (!dst->extended_buf) {

280 ret = AVERROR(ENOMEM);

281 goto fail;

282 }

283 dst->nb_extended_buf = src->nb_extended_buf;

284

285 for (i = 0; i < src->nb_extended_buf; i++) {

286 dst->extended_buf[i] = av_buffer_ref(src->extended_buf[i]);

287 if (!dst->extended_buf[i]) {

288 ret = AVERROR(ENOMEM);

289 goto fail;

290 }

291 }

292 }

293

294 /* duplicate extended data */

295 if (src->extended_data != src->data) {

296 int ch = src->channels;

297

298 if (!ch) {

299 ret = AVERROR(EINVAL);

300 goto fail;

301 }

302 CHECK_CHANNELS_CONSISTENCY(src);

303

304 dst->extended_data = av_malloc(sizeof(*dst->extended_data) * ch);

305 if (!dst->extended_data) {

306 ret = AVERROR(ENOMEM);

307 goto fail;

308 }

309 memcpy(dst->extended_data, src->extended_data, sizeof(*src->extended_data) * ch);

310 } else

311 dst->extended_data = dst->data;

312

313 memcpy(dst->data, src->data, sizeof(src->data));

314 memcpy(dst->linesize, src->linesize, sizeof(src->linesize));

315

316 return 0;

317

318 fail:

319 av_frame_unref(dst);

320 return ret;

321 }

322

323 AVFrame *av_frame_clone(AVFrame *src)

324 {

325 AVFrame *ret = av_frame_alloc();

326

327 if (!ret)

328 return NULL;

329

330 if (av_frame_ref(ret, src) < 0)

331 av_frame_free(&ret);

332

333 return ret;

334 }

335

336 void av_frame_unref(AVFrame *frame)

337 {

338 int i;

339

340 for (i = 0; i < frame->nb_side_data; i++) {

341 av_freep(&frame->side_data[i]->data);

342 av_dict_free(&frame->side_data[i]->metadata);

343 av_freep(&frame->side_data[i]);

344 }

345 av_freep(&frame->side_data);

346

347 for (i = 0; i < FF_ARRAY_ELEMS(frame->buf); i++)

348 av_buffer_unref(&frame->buf[i]);

349 for (i = 0; i < frame->nb_extended_buf; i++)

350 av_buffer_unref(&frame->extended_buf[i]);

351 av_freep(&frame->extended_buf);

352 av_dict_free(&frame->metadata);

353 av_buffer_unref(&frame->qp_table_buf);

354

355 get_frame_defaults(frame);

356 }

357

358 void av_frame_move_ref(AVFrame *dst, AVFrame *src)

359 {

360 *dst = *src;

361 if (src->extended_data == src->data)

362 dst->extended_data = dst->data;

363 memset(src, 0, sizeof(*src));

364 get_frame_defaults(src);

365 }

366

367 int av_frame_is_writable(AVFrame *frame)

368 {

369 int i, ret = 1;

370

371 /* assume non-refcounted frames are not writable */

372 if (!frame->buf[0])

373 return 0;

374

375 for (i = 0; i < FF_ARRAY_ELEMS(frame->buf); i++)

376 if (frame->buf[i])

377 ret &= !!av_buffer_is_writable(frame->buf[i]);

378 for (i = 0; i < frame->nb_extended_buf; i++)

379 ret &= !!av_buffer_is_writable(frame->extended_buf[i]);

380

381 return ret;

382 }

383

384 int av_frame_make_writable(AVFrame *frame)

385 {

386 AVFrame tmp;

387 int ret;

388

389 if (!frame->buf[0])

390 return AVERROR(EINVAL);

391

392 if (av_frame_is_writable(frame))

393 return 0;

394

395 memset(&tmp, 0, sizeof(tmp));

396 tmp.format = frame->format;

397 tmp.width = frame->width;

398 tmp.height = frame->height;

399 tmp.channels = frame->channels;

400 tmp.channel_layout = frame->channel_layout;

401 tmp.nb_samples = frame->nb_samples;

402 ret = av_frame_get_buffer(&tmp, 32);

403 if (ret < 0)

404 return ret;

405

406 if (tmp.nb_samples) {

407 int ch = tmp.channels;

408 CHECK_CHANNELS_CONSISTENCY(&tmp);

409 av_samples_copy(tmp.extended_data, frame->extended_data, 0, 0,

410 frame->nb_samples, ch, frame->format);

411 } else {

412 av_image_copy(tmp.data, tmp.linesize, frame->data, frame->linesize,

413 frame->format, frame->width, frame->height);

414 }

415

416 ret = av_frame_copy_props(&tmp, frame);

417 if (ret < 0) {

418 av_frame_unref(&tmp);

419 return ret;

420 }

421

422 av_frame_unref(frame);

423

424 *frame = tmp;

425 if (tmp.data == tmp.extended_data)

426 frame->extended_data = frame->data;

427

428 return 0;

429 }

430

431 int av_frame_copy_props(AVFrame *dst, const AVFrame *src)

432 {

433 int i;

434

435 dst->key_frame = src->key_frame;

436 dst->pict_type = src->pict_type;

437 dst->sample_aspect_ratio = src->sample_aspect_ratio;

438 dst->pts = src->pts;

439 dst->repeat_pict = src->repeat_pict;

440 dst->interlaced_frame = src->interlaced_frame;

441 dst->top_field_first = src->top_field_first;

442 dst->palette_has_changed = src->palette_has_changed;

443 dst->sample_rate = src->sample_rate;

444 dst->opaque = src->opaque;

445 #if FF_API_AVFRAME_LAVC

446 dst->type = src->type;

447 #endif

448 dst->pkt_pts = src->pkt_pts;

449 dst->pkt_dts = src->pkt_dts;

450 dst->pkt_pos = src->pkt_pos;

451 dst->pkt_size = src->pkt_size;

452 dst->pkt_duration = src->pkt_duration;

453 dst->reordered_opaque = src->reordered_opaque;

454 dst->quality = src->quality;

455 dst->best_effort_timestamp = src->best_effort_timestamp;

456 dst->coded_picture_number = src->coded_picture_number;

457 dst->display_picture_number = src->display_picture_number;

458 dst->decode_error_flags = src->decode_error_flags;

459

460 av_dict_copy(&dst->metadata, src->metadata, 0);

461

462 memcpy(dst->error, src->error, sizeof(dst->error));

463

464 for (i = 0; i < src->nb_side_data; i++) {

465 const AVFrameSideData *sd_src = src->side_data[i];

466 AVFrameSideData *sd_dst = av_frame_new_side_data(dst, sd_src->type,

467 sd_src->size);

468 if (!sd_dst) {

469 for (i = 0; i < dst->nb_side_data; i++) {

470 av_freep(&dst->side_data[i]->data);

471 av_freep(&dst->side_data[i]);

472 av_dict_free(&dst->side_data[i]->metadata);

473 }

474 av_freep(&dst->side_data);

475 return AVERROR(ENOMEM);

476 }

477 memcpy(sd_dst->data, sd_src->data, sd_src->size);

478 av_dict_copy(&sd_dst->metadata, sd_src->metadata, 0);

479 }

480

481 dst->qscale_table = NULL;

482 dst->qstride = 0;

483 dst->qscale_type = 0;

484 if (src->qp_table_buf) {

485 dst->qp_table_buf = av_buffer_ref(src->qp_table_buf);

486 if (dst->qp_table_buf) {

487 dst->qscale_table = dst->qp_table_buf->data;

488 dst->qstride = src->qstride;

489 dst->qscale_type = src->qscale_type;

490 }

491 }

492

493 return 0;

494 }

495

496 AVBufferRef *av_frame_get_plane_buffer(AVFrame *frame, int plane)

497 {

498 uint8_t *data;

499 int planes, i;

500

501 if (frame->nb_samples) {

502 int channels = frame->channels;

503 if (!channels)

504 return NULL;

505 CHECK_CHANNELS_CONSISTENCY(frame);

506 planes = av_sample_fmt_is_planar(frame->format) ? channels : 1;

507 } else

508 planes = 4;

509

510 if (plane < 0 || plane >= planes || !frame->extended_data[plane])

511 return NULL;

512 data = frame->extended_data[plane];

513

514 for (i = 0; i < FF_ARRAY_ELEMS(frame->buf) && frame->buf[i]; i++) {

515 AVBufferRef *buf = frame->buf[i];

516 if (data >= buf->data && data < buf->data + buf->size)

517 return buf;

518 }

519 for (i = 0; i < frame->nb_extended_buf; i++) {

520 AVBufferRef *buf = frame->extended_buf[i];

521 if (data >= buf->data && data < buf->data + buf->size)

522 return buf;

523 }

524 return NULL;

525 }

526

527 AVFrameSideData *av_frame_new_side_data(AVFrame *frame,

528 enum AVFrameSideDataType type,

529 int size)

530 {

531 AVFrameSideData *ret, **tmp;

532

533 if (frame->nb_side_data > INT_MAX / sizeof(*frame->side_data) - 1)

534 return NULL;

535

536 tmp = av_realloc(frame->side_data,

537 (frame->nb_side_data + 1) * sizeof(*frame->side_data));

538 if (!tmp)

539 return NULL;

540 frame->side_data = tmp;

541

542 ret = av_mallocz(sizeof(*ret));

543 if (!ret)

544 return NULL;

545

546 ret->data = av_malloc(size);

547 if (!ret->data) {

548 av_freep(&ret);

549 return NULL;

550 }

551

552 ret->size = size;

553 ret->type = type;

554

555 frame->side_data[frame->nb_side_data++] = ret;

556

557 return ret;

558 }

559

560 AVFrameSideData *av_frame_get_side_data(AVFrame *frame,

561 enum AVFrameSideDataType type)

562 {

563 int i;

564

565 for (i = 0; i < frame->nb_side_data; i++) {

566 if (frame->side_data[i]->type == type)

567 return frame->side_data[i];

568 }

569 return NULL;

570 }

Generated on Wed Jul 10 2013 23:48:15 for FFmpeg by doxygen 1.8.2