FFmpeg: libavcodec/vda_h264.c Source File

FFmpeg

[フレーム]

libavcodec

vda_h264.c

Go to the documentation of this file.

1 /*

2 * VDA H264 HW acceleration.

3 *

5 *

6 * This file is part of FFmpeg.

7 *

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

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

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

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

12 *

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

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

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

16 * Lesser General Public License for more details.

17 *

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

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

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

21 */

23 #include <CoreFoundation/CFDictionary.h>

24 #include <CoreFoundation/CFNumber.h>

25 #include <CoreFoundation/CFData.h>

27 #include "vda.h"

28 #include "libavutil/avutil.h"

29 #include "h264.h"

31 struct vda_buffer {

32 CVPixelBufferRef cv_buffer;

33 };

34 #include "internal.h"

35 #include "vda_internal.h"

37 typedef struct VDAContext {

38 // The current bitstream buffer.

39 uint8_t *bitstream;

41 // The current size of the bitstream.

42 int bitstream_size;

44 // The reference size used for fast reallocation.

45 int allocated_size;

47 CVImageBufferRef frame;

48 } VDAContext;

50 /* Decoder callback that adds the vda frame to the queue in display order. */

51 static void vda_decoder_callback(void *vda_hw_ctx,

52 CFDictionaryRef user_info,

53 OSStatus status,

54 uint32_t infoFlags,

55 CVImageBufferRef image_buffer)

56 {

57 struct vda_context *vda_ctx = vda_hw_ctx;

59 if (infoFlags & kVDADecodeInfo_FrameDropped)

60 vda_ctx->cv_buffer = NULL;

62 if (!image_buffer)

63 return;

65 if (vda_ctx->cv_pix_fmt_type != CVPixelBufferGetPixelFormatType(image_buffer))

66 return;

68 vda_ctx->cv_buffer = CVPixelBufferRetain(image_buffer);

69 }

71 static int vda_sync_decode(VDAContext *ctx, struct vda_context *vda_ctx)

72 {

73 OSStatus status;

74 CFDataRef coded_frame;

75 uint32_t flush_flags = 1 << 0; ///< kVDADecoderFlush_emitFrames

77 coded_frame = CFDataCreate(kCFAllocatorDefault,

78 ctx->bitstream,

79 ctx->bitstream_size);

81 status = VDADecoderDecode(vda_ctx->decoder, 0, coded_frame, NULL);

83 if (kVDADecoderNoErr == status)

84 status = VDADecoderFlush(vda_ctx->decoder, flush_flags);

86 CFRelease(coded_frame);

88 return status;

89 }

92 static int vda_old_h264_start_frame(AVCodecContext *avctx,

93 av_unused const uint8_t *buffer,

94 av_unused uint32_t size)

95 {

96 VDAContext *vda = avctx->internal->hwaccel_priv_data;

97 struct vda_context *vda_ctx = avctx->hwaccel_context;

99 if (!vda_ctx->decoder)

100 return -1;

101

102 vda->bitstream_size = 0;

103

104 return 0;

105 }

106

107 static int vda_old_h264_decode_slice(AVCodecContext *avctx,

108 const uint8_t *buffer,

109 uint32_t size)

110 {

111 VDAContext *vda = avctx->internal->hwaccel_priv_data;

112 struct vda_context *vda_ctx = avctx->hwaccel_context;

113 void *tmp;

114

115 if (!vda_ctx->decoder)

116 return -1;

117

118 tmp = av_fast_realloc(vda->bitstream,

119 &vda->allocated_size,

120 vda->bitstream_size + size + 4);

121 if (!tmp)

122 return AVERROR(ENOMEM);

123

124 vda->bitstream = tmp;

125

126 AV_WB32(vda->bitstream + vda->bitstream_size, size);

127 memcpy(vda->bitstream + vda->bitstream_size + 4, buffer, size);

128

129 vda->bitstream_size += size + 4;

130

131 return 0;

132 }

133

134 static void vda_h264_release_buffer(void *opaque, uint8_t *data)

135 {

136 struct vda_buffer *context = opaque;

137 CVPixelBufferRelease(context->cv_buffer);

138 av_free(context);

139 }

140

141 static int vda_old_h264_end_frame(AVCodecContext *avctx)

142 {

143 H264Context *h = avctx->priv_data;

144 VDAContext *vda = avctx->internal->hwaccel_priv_data;

145 struct vda_context *vda_ctx = avctx->hwaccel_context;

146 AVFrame *frame = &h->cur_pic_ptr->f;

147 struct vda_buffer *context;

148 AVBufferRef *buffer;

149 int status;

150

151 if (!vda_ctx->decoder || !vda->bitstream)

152 return -1;

153

154 status = vda_sync_decode(vda, vda_ctx);

155 frame->data[3] = (void*)vda_ctx->cv_buffer;

156

157 if (status)

158 av_log(avctx, AV_LOG_ERROR, "Failed to decode frame (%d)\n", status);

159

160 if (!vda_ctx->use_ref_buffer || status)

161 return status;

162

163 context = av_mallocz(sizeof(*context));

164 buffer = av_buffer_create(NULL, 0, vda_h264_release_buffer, context, 0);

165 if (!context || !buffer) {

166 CVPixelBufferRelease(vda_ctx->cv_buffer);

167 av_free(context);

168 return -1;

169 }

170

171 context->cv_buffer = vda_ctx->cv_buffer;

172 frame->buf[3] = buffer;

173

174 return status;

175 }

176

177 int ff_vda_create_decoder(struct vda_context *vda_ctx,

178 uint8_t *extradata,

179 int extradata_size)

180 {

181 OSStatus status;

182 CFNumberRef height;

183 CFNumberRef width;

184 CFNumberRef format;

185 CFDataRef avc_data;

186 CFMutableDictionaryRef config_info;

187 CFMutableDictionaryRef buffer_attributes;

188 CFMutableDictionaryRef io_surface_properties;

189 CFNumberRef cv_pix_fmt;

190

191 vda_ctx->priv_bitstream = NULL;

192 vda_ctx->priv_allocated_size = 0;

193

194 /* Each VCL NAL in the bitstream sent to the decoder

195 * is preceded by a 4 bytes length header.

196 * Change the avcC atom header if needed, to signal headers of 4 bytes. */

197 if (extradata_size >= 4 && (extradata[4] & 0x03) != 0x03) {

198 uint8_t *rw_extradata;

199

200 if (!(rw_extradata = av_malloc(extradata_size)))

201 return AVERROR(ENOMEM);

202

203 memcpy(rw_extradata, extradata, extradata_size);

204

205 rw_extradata[4] |= 0x03;

206

207 avc_data = CFDataCreate(kCFAllocatorDefault, rw_extradata, extradata_size);

208

209 av_freep(&rw_extradata);

210 } else {

211 avc_data = CFDataCreate(kCFAllocatorDefault, extradata, extradata_size);

212 }

213

214 config_info = CFDictionaryCreateMutable(kCFAllocatorDefault,

215 4,

216 &kCFTypeDictionaryKeyCallBacks,

217 &kCFTypeDictionaryValueCallBacks);

218

219 height = CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt32Type, &vda_ctx->height);

220 width = CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt32Type, &vda_ctx->width);

221 format = CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt32Type, &vda_ctx->format);

222

223 CFDictionarySetValue(config_info, kVDADecoderConfiguration_Height, height);

224 CFDictionarySetValue(config_info, kVDADecoderConfiguration_Width, width);

225 CFDictionarySetValue(config_info, kVDADecoderConfiguration_SourceFormat, format);

226 CFDictionarySetValue(config_info, kVDADecoderConfiguration_avcCData, avc_data);

227

228 buffer_attributes = CFDictionaryCreateMutable(kCFAllocatorDefault,

229 2,

230 &kCFTypeDictionaryKeyCallBacks,

231 &kCFTypeDictionaryValueCallBacks);

232 io_surface_properties = CFDictionaryCreateMutable(kCFAllocatorDefault,

233 0,

234 &kCFTypeDictionaryKeyCallBacks,

235 &kCFTypeDictionaryValueCallBacks);

236 cv_pix_fmt = CFNumberCreate(kCFAllocatorDefault,

237 kCFNumberSInt32Type,

238 &vda_ctx->cv_pix_fmt_type);

239 CFDictionarySetValue(buffer_attributes,

240 kCVPixelBufferPixelFormatTypeKey,

241 cv_pix_fmt);

242 CFDictionarySetValue(buffer_attributes,

243 kCVPixelBufferIOSurfacePropertiesKey,

244 io_surface_properties);

245

246 status = VDADecoderCreate(config_info,

247 buffer_attributes,

248 (VDADecoderOutputCallback *)vda_decoder_callback,

249 vda_ctx,

250 &vda_ctx->decoder);

251

252 CFRelease(height);

253 CFRelease(width);

254 CFRelease(format);

255 CFRelease(avc_data);

256 CFRelease(config_info);

257 CFRelease(io_surface_properties);

258 CFRelease(cv_pix_fmt);

259 CFRelease(buffer_attributes);

260

261 return status;

262 }

263

264 int ff_vda_destroy_decoder(struct vda_context *vda_ctx)

265 {

266 OSStatus status = kVDADecoderNoErr;

267

268 if (vda_ctx->decoder)

269 status = VDADecoderDestroy(vda_ctx->decoder);

270

271 return status;

272 }

273

274 static int vda_h264_uninit(AVCodecContext *avctx)

275 {

276 VDAContext *vda = avctx->internal->hwaccel_priv_data;

277 if (vda) {

278 av_freep(&vda->bitstream);

279 if (vda->frame)

280 CVPixelBufferRelease(vda->frame);

281 }

282 return 0;

283 }

284

285 AVHWAccel ff_h264_vda_old_hwaccel = {

286 .name = "h264_vda",

287 .type = AVMEDIA_TYPE_VIDEO,

288 .id = AV_CODEC_ID_H264,

289 .pix_fmt = AV_PIX_FMT_VDA_VLD,

290 .start_frame = vda_old_h264_start_frame,

291 .decode_slice = vda_old_h264_decode_slice,

292 .end_frame = vda_old_h264_end_frame,

293 .uninit = vda_h264_uninit,

294 .priv_data_size = sizeof(VDAContext),

295 };

296

297 void ff_vda_output_callback(void *opaque,

298 CFDictionaryRef user_info,

299 OSStatus status,

300 uint32_t infoFlags,

301 CVImageBufferRef image_buffer)

302 {

303 AVCodecContext *ctx = opaque;

304 VDAContext *vda = ctx->internal->hwaccel_priv_data;

305

306

307 if (vda->frame) {

308 CVPixelBufferRelease(vda->frame);

309 vda->frame = NULL;

310 }

311

312 if (!image_buffer)

313 return;

314

315 vda->frame = CVPixelBufferRetain(image_buffer);

316 }

317

318 static int vda_h264_start_frame(AVCodecContext *avctx,

319 const uint8_t *buffer,

320 uint32_t size)

321 {

322 VDAContext *vda = avctx->internal->hwaccel_priv_data;

323

324 vda->bitstream_size = 0;

325

326 return 0;

327 }

328

329 static int vda_h264_decode_slice(AVCodecContext *avctx,

330 const uint8_t *buffer,

331 uint32_t size)

332 {

333 VDAContext *vda = avctx->internal->hwaccel_priv_data;

334 void *tmp;

335

336 tmp = av_fast_realloc(vda->bitstream,

337 &vda->allocated_size,

338 vda->bitstream_size + size + 4);

339 if (!tmp)

340 return AVERROR(ENOMEM);

341

342 vda->bitstream = tmp;

343

344 AV_WB32(vda->bitstream + vda->bitstream_size, size);

345 memcpy(vda->bitstream + vda->bitstream_size + 4, buffer, size);

346

347 vda->bitstream_size += size + 4;

348

349 return 0;

350 }

351

352 static void release_buffer(void *opaque, uint8_t *data)

353 {

354 CVImageBufferRef frame = (CVImageBufferRef)data;

355 CVPixelBufferRelease(frame);

356 }

357

358 static int vda_h264_end_frame(AVCodecContext *avctx)

359 {

360 H264Context *h = avctx->priv_data;

361 VDAContext *vda = avctx->internal->hwaccel_priv_data;

362 AVVDAContext *vda_ctx = avctx->hwaccel_context;

363 AVFrame *frame = &h->cur_pic_ptr->f;

364 uint32_t flush_flags = 1 << 0; ///< kVDADecoderFlush_emitFrames

365 CFDataRef coded_frame;

366 OSStatus status;

367

368 if (!vda->bitstream_size)

369 return AVERROR_INVALIDDATA;

370

371

372 coded_frame = CFDataCreate(kCFAllocatorDefault,

373 vda->bitstream,

374 vda->bitstream_size);

375

376 status = VDADecoderDecode(vda_ctx->decoder, 0, coded_frame, NULL);

377

378 if (status == kVDADecoderNoErr)

379 status = VDADecoderFlush(vda_ctx->decoder, flush_flags);

380

381 CFRelease(coded_frame);

382

383 if (!vda->frame)

384 return AVERROR_UNKNOWN;

385

386 if (status != kVDADecoderNoErr) {

387 av_log(avctx, AV_LOG_ERROR, "Failed to decode frame (%d)\n", status);

388 return AVERROR_UNKNOWN;

389 }

390

391 av_buffer_unref(&frame->buf[0]);

392

393 frame->buf[0] = av_buffer_create((uint8_t*)vda->frame,

394 sizeof(vda->frame),

395 release_buffer, NULL,

396 AV_BUFFER_FLAG_READONLY);

397 if (!frame->buf)

398 return AVERROR(ENOMEM);

399

400 frame->data[3] = (uint8_t*)vda->frame;

401 vda->frame = NULL;

402

403 return 0;

404 }

405

406 int ff_vda_default_init(AVCodecContext *avctx)

407 {

408 AVVDAContext *vda_ctx = avctx->hwaccel_context;

409 OSStatus status = kVDADecoderNoErr;

410 CFNumberRef height;

411 CFNumberRef width;

412 CFNumberRef format;

413 CFDataRef avc_data;

414 CFMutableDictionaryRef config_info;

415 CFMutableDictionaryRef buffer_attributes;

416 CFMutableDictionaryRef io_surface_properties;

417 CFNumberRef cv_pix_fmt;

418 int32_t fmt = 'avc1', pix_fmt = kCVPixelFormatType_422YpCbCr8;

419

420 // kCVPixelFormatType_420YpCbCr8Planar;

421

422 /* Each VCL NAL in the bitstream sent to the decoder

423 * is preceded by a 4 bytes length header.

424 * Change the avcC atom header if needed, to signal headers of 4 bytes. */

425 if (avctx->extradata_size >= 4 && (avctx->extradata[4] & 0x03) != 0x03) {

426 uint8_t *rw_extradata;

427

428 if (!(rw_extradata = av_malloc(avctx->extradata_size)))

429 return AVERROR(ENOMEM);

430

431 memcpy(rw_extradata, avctx->extradata, avctx->extradata_size);

432

433 rw_extradata[4] |= 0x03;

434

435 avc_data = CFDataCreate(kCFAllocatorDefault, rw_extradata, avctx->extradata_size);

436

437 av_freep(&rw_extradata);

438 } else {

439 avc_data = CFDataCreate(kCFAllocatorDefault,

440 avctx->extradata, avctx->extradata_size);

441 }

442

443 config_info = CFDictionaryCreateMutable(kCFAllocatorDefault,

444 4,

445 &kCFTypeDictionaryKeyCallBacks,

446 &kCFTypeDictionaryValueCallBacks);

447

448 height = CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt32Type, &avctx->height);

449 width = CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt32Type, &avctx->width);

450 format = CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt32Type, &fmt);

451 CFDictionarySetValue(config_info, kVDADecoderConfiguration_Height, height);

452 CFDictionarySetValue(config_info, kVDADecoderConfiguration_Width, width);

453 CFDictionarySetValue(config_info, kVDADecoderConfiguration_avcCData, avc_data);

454 CFDictionarySetValue(config_info, kVDADecoderConfiguration_SourceFormat, format);

455

456 buffer_attributes = CFDictionaryCreateMutable(kCFAllocatorDefault,

457 2,

458 &kCFTypeDictionaryKeyCallBacks,

459 &kCFTypeDictionaryValueCallBacks);

460 io_surface_properties = CFDictionaryCreateMutable(kCFAllocatorDefault,

461 0,

462 &kCFTypeDictionaryKeyCallBacks,

463 &kCFTypeDictionaryValueCallBacks);

464 cv_pix_fmt = CFNumberCreate(kCFAllocatorDefault,

465 kCFNumberSInt32Type,

466 &pix_fmt);

467

468 CFDictionarySetValue(buffer_attributes,

469 kCVPixelBufferPixelFormatTypeKey,

470 cv_pix_fmt);

471 CFDictionarySetValue(buffer_attributes,

472 kCVPixelBufferIOSurfacePropertiesKey,

473 io_surface_properties);

474

475 status = VDADecoderCreate(config_info,

476 buffer_attributes,

477 (VDADecoderOutputCallback *)ff_vda_output_callback,

478 avctx,

479 &vda_ctx->decoder);

480

481 CFRelease(format);

482 CFRelease(height);

483 CFRelease(width);

484 CFRelease(avc_data);

485 CFRelease(config_info);

486 CFRelease(cv_pix_fmt);

487 CFRelease(io_surface_properties);

488 CFRelease(buffer_attributes);

489

490 if (status != kVDADecoderNoErr) {

491 av_log(avctx, AV_LOG_ERROR, "Cannot initialize VDA %d\n", status);

492 }

493

494 switch (status) {

495 case kVDADecoderHardwareNotSupportedErr:

496 case kVDADecoderFormatNotSupportedErr:

497 return AVERROR(ENOSYS);

498 case kVDADecoderConfigurationError:

499 return AVERROR(EINVAL);

500 case kVDADecoderDecoderFailedErr:

501 return AVERROR_INVALIDDATA;

502 case kVDADecoderNoErr:

503 return 0;

504 default:

505 return AVERROR_UNKNOWN;

506 }

507 }

508

509 static int vda_h264_alloc_frame(AVCodecContext *avctx, AVFrame *frame)

510 {

511 frame->width = avctx->width;

512 frame->height = avctx->height;

513 frame->format = avctx->pix_fmt;

514 frame->buf[0] = av_buffer_alloc(1);

515

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

517 return AVERROR(ENOMEM);

518 return 0;

519 }

520

521 AVHWAccel ff_h264_vda_hwaccel = {

522 .name = "h264_vda",

523 .type = AVMEDIA_TYPE_VIDEO,

524 .id = AV_CODEC_ID_H264,

525 .pix_fmt = AV_PIX_FMT_VDA,

526 .alloc_frame = vda_h264_alloc_frame,

527 .start_frame = vda_h264_start_frame,

528 .decode_slice = vda_h264_decode_slice,

529 .end_frame = vda_h264_end_frame,

530 .uninit = vda_h264_uninit,

531 .priv_data_size = sizeof(VDAContext),

532 };

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