git.sesse.net Git - ffmpeg/blob - libavcodec/mediacodecdec.c

   1 /*
   2  * Android MediaCodec H.264 / H.265 / MPEG-4 / VP8 / VP9 decoders
   3  *
   4  * Copyright (c) 2015-2016 Matthieu Bouron <matthieu.bouron stupeflix.com>
   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  */
  22
  23 #include <stdint.h>
  24 #include <string.h>
  25
  26 #include "libavutil/avassert.h"
  27 #include "libavutil/common.h"
  28 #include "libavutil/fifo.h"
  29 #include "libavutil/opt.h"
  30 #include "libavutil/intreadwrite.h"
  31 #include "libavutil/pixfmt.h"
  32 #include "libavutil/atomic.h"
  33
  34 #include "avcodec.h"
  35 #include "h264_parse.h"
  36 #include "hevc_parse.h"
  37 #include "internal.h"
  38 #include "mediacodec_wrapper.h"
  39 #include "mediacodecdec_common.h"
  40
  41 typedef struct MediaCodecH264DecContext {
  42
  43     MediaCodecDecContext *ctx;
  44
  45     AVBSFContext *bsf;
  46
  47     AVFifoBuffer *fifo;
  48
  49     AVPacket filtered_pkt;
  50
  51 } MediaCodecH264DecContext;
  52
  53 static av_cold int mediacodec_decode_close(AVCodecContext *avctx)
  54 {
  55     MediaCodecH264DecContext *s = avctx->priv_data;
  56
  57     ff_mediacodec_dec_close(avctx, s->ctx);
  58     s->ctx = NULL;
  59
  60     av_fifo_free(s->fifo);
  61
  62     av_bsf_free(&s->bsf);
  63     av_packet_unref(&s->filtered_pkt);
  64
  65     return 0;
  66 }
  67
  68 #if CONFIG_H264_MEDIACODEC_DECODER || CONFIG_HEVC_MEDIACODEC_DECODER
  69 static int h2645_ps_to_nalu(const uint8_t *src, int src_size, uint8_t **out, int *out_size)
  70 {
  71     int i;
  72     int ret = 0;
  73     uint8_t *p = NULL;
  74     static const uint8_t nalu_header[] = { 0x00, 0x00, 0x00, 0x01 };
  75
  76     if (!out || !out_size) {
  77         return AVERROR(EINVAL);
  78     }
  79
  80     p = av_malloc(sizeof(nalu_header) + src_size);
  81     if (!p) {
  82         return AVERROR(ENOMEM);
  83     }
  84
  85     *out = p;
  86     *out_size = sizeof(nalu_header) + src_size;
  87
  88     memcpy(p, nalu_header, sizeof(nalu_header));
  89     memcpy(p + sizeof(nalu_header), src, src_size);
  90
  91     /* Escape 0x00, 0x00, 0x0{0-3} pattern */
  92     for (i = 4; i < *out_size; i++) {
  93         if (i < *out_size - 3 &&
  94             p[i + 0] == 0 &&
  95             p[i + 1] == 0 &&
  96             p[i + 2] <= 3) {
  97             uint8_t *new;
  98
  99             *out_size += 1;
 100             new = av_realloc(*out, *out_size);
 101             if (!new) {
 102                 ret = AVERROR(ENOMEM);
 103                 goto done;
 104             }
 105             *out = p = new;
 106
 107             i = i + 2;
 108             memmove(p + i + 1, p + i, *out_size - (i + 1));
 109             p[i] = 0x03;
 110         }
 111     }
 112 done:
 113     if (ret < 0) {
 114         av_freep(out);
 115         *out_size = 0;
 116     }
 117
 118     return ret;
 119 }
 120 #endif
 121
 122 #if CONFIG_H264_MEDIACODEC_DECODER
 123 static int h264_set_extradata(AVCodecContext *avctx, FFAMediaFormat *format)
 124 {
 125     int i;
 126     int ret;
 127
 128     H264ParamSets ps;
 129     const PPS *pps = NULL;
 130     const SPS *sps = NULL;
 131     int is_avc = 0;
 132     int nal_length_size = 0;
 133
 134     memset(&ps, 0, sizeof(ps));
 135
 136     ret = ff_h264_decode_extradata(avctx->extradata, avctx->extradata_size,
 137                                    &ps, &is_avc, &nal_length_size, 0, avctx);
 138     if (ret < 0) {
 139         goto done;
 140     }
 141
 142     for (i = 0; i < MAX_PPS_COUNT; i++) {
 143         if (ps.pps_list[i]) {
 144             pps = (const PPS*)ps.pps_list[i]->data;
 145             break;
 146         }
 147     }
 148
 149     if (pps) {
 150         if (ps.sps_list[pps->sps_id]) {
 151             sps = (const SPS*)ps.sps_list[pps->sps_id]->data;
 152         }
 153     }
 154
 155     if (pps && sps) {
 156         uint8_t *data = NULL;
 157         int data_size = 0;
 158
 159         if ((ret = h2645_ps_to_nalu(sps->data, sps->data_size, &data, &data_size)) < 0) {
 160             goto done;
 161         }
 162         ff_AMediaFormat_setBuffer(format, "csd-0", (void*)data, data_size);
 163         av_freep(&data);
 164
 165         if ((ret = h2645_ps_to_nalu(pps->data, pps->data_size, &data, &data_size)) < 0) {
 166             goto done;
 167         }
 168         ff_AMediaFormat_setBuffer(format, "csd-1", (void*)data, data_size);
 169         av_freep(&data);
 170     } else {
 171         av_log(avctx, AV_LOG_ERROR, "Could not extract PPS/SPS from extradata");
 172         ret = AVERROR_INVALIDDATA;
 173     }
 174
 175 done:
 176     ff_h264_ps_uninit(&ps);
 177
 178     return ret;
 179 }
 180 #endif
 181
 182 #if CONFIG_HEVC_MEDIACODEC_DECODER
 183 static int hevc_set_extradata(AVCodecContext *avctx, FFAMediaFormat *format)
 184 {
 185     int i;
 186     int ret;
 187
 188     HEVCParamSets ps;
 189
 190     const HEVCVPS *vps = NULL;
 191     const HEVCPPS *pps = NULL;
 192     const HEVCSPS *sps = NULL;
 193     int is_nalff = 0;
 194     int nal_length_size = 0;
 195
 196     uint8_t *vps_data = NULL;
 197     uint8_t *sps_data = NULL;
 198     uint8_t *pps_data = NULL;
 199     int vps_data_size = 0;
 200     int sps_data_size = 0;
 201     int pps_data_size = 0;
 202
 203     memset(&ps, 0, sizeof(ps));
 204
 205     ret = ff_hevc_decode_extradata(avctx->extradata, avctx->extradata_size,
 206                                 &ps, &is_nalff, &nal_length_size, 0, avctx);
 207     if (ret < 0) {
 208         goto done;
 209     }
 210
 211     for (i = 0; i < MAX_VPS_COUNT; i++) {
 212         if (ps.vps_list[i]) {
 213             vps = (const HEVCVPS*)ps.vps_list[i]->data;
 214             break;
 215         }
 216     }
 217
 218     for (i = 0; i < MAX_PPS_COUNT; i++) {
 219         if (ps.pps_list[i]) {
 220             pps = (const HEVCPPS*)ps.pps_list[i]->data;
 221             break;
 222         }
 223     }
 224
 225     if (pps) {
 226         if (ps.sps_list[pps->sps_id]) {
 227             sps = (const HEVCSPS*)ps.sps_list[pps->sps_id]->data;
 228         }
 229     }
 230
 231     if (vps && pps && sps) {
 232         uint8_t *data;
 233         int data_size;
 234
 235         if ((ret = h2645_ps_to_nalu(vps->data, vps->data_size, &vps_data, &vps_data_size)) < 0 ||
 236             (ret = h2645_ps_to_nalu(sps->data, sps->data_size, &sps_data, &sps_data_size)) < 0 ||
 237             (ret = h2645_ps_to_nalu(pps->data, pps->data_size, &pps_data, &pps_data_size)) < 0) {
 238             goto done;
 239         }
 240
 241         data_size = vps_data_size + sps_data_size + pps_data_size;
 242         data = av_mallocz(data_size);
 243         if (!data) {
 244             ret = AVERROR(ENOMEM);
 245             goto done;
 246         }
 247
 248         memcpy(data                                , vps_data, vps_data_size);
 249         memcpy(data + vps_data_size                , sps_data, sps_data_size);
 250         memcpy(data + vps_data_size + sps_data_size, pps_data, pps_data_size);
 251
 252         ff_AMediaFormat_setBuffer(format, "csd-0", data, data_size);
 253
 254         av_freep(&data);
 255     } else {
 256         av_log(avctx, AV_LOG_ERROR, "Could not extract VPS/PPS/SPS from extradata");
 257         ret = AVERROR_INVALIDDATA;
 258     }
 259
 260 done:
 261     av_freep(&vps_data);
 262     av_freep(&sps_data);
 263     av_freep(&pps_data);
 264
 265     return ret;
 266 }
 267 #endif
 268
 269 #if CONFIG_MPEG4_MEDIACODEC_DECODER
 270 static int mpeg4_set_extradata(AVCodecContext *avctx, FFAMediaFormat *format)
 271 {
 272     int ret = 0;
 273
 274     if (avctx->extradata) {
 275         ff_AMediaFormat_setBuffer(format, "csd-0", avctx->extradata, avctx->extradata_size);
 276     }
 277
 278     return ret;
 279 }
 280 #endif
 281
 282 #if CONFIG_VP8_MEDIACODEC_DECODER || CONFIG_VP9_MEDIACODEC_DECODER
 283 static int vpx_set_extradata(AVCodecContext *avctx, FFAMediaFormat *format)
 284 {
 285     int ret = 0;
 286
 287     if (avctx->extradata) {
 288         ff_AMediaFormat_setBuffer(format, "csd-0", avctx->extradata, avctx->extradata_size);
 289     }
 290
 291     return ret;
 292 }
 293 #endif
 294
 295 static av_cold int mediacodec_decode_init(AVCodecContext *avctx)
 296 {
 297     int ret;
 298
 299     const char *codec_mime = NULL;
 300
 301     const char *bsf_name = NULL;
 302     const AVBitStreamFilter *bsf = NULL;
 303
 304     FFAMediaFormat *format = NULL;
 305     MediaCodecH264DecContext *s = avctx->priv_data;
 306
 307     format = ff_AMediaFormat_new();
 308     if (!format) {
 309         av_log(avctx, AV_LOG_ERROR, "Failed to create media format\n");
 310         ret = AVERROR_EXTERNAL;
 311         goto done;
 312     }
 313
 314     switch (avctx->codec_id) {
 315 #if CONFIG_H264_MEDIACODEC_DECODER
 316     case AV_CODEC_ID_H264:
 317         codec_mime = "video/avc";
 318         bsf_name = "h264_mp4toannexb";
 319
 320         ret = h264_set_extradata(avctx, format);
 321         if (ret < 0)
 322             goto done;
 323         break;
 324 #endif
 325 #if CONFIG_HEVC_MEDIACODEC_DECODER
 326     case AV_CODEC_ID_HEVC:
 327         codec_mime = "video/hevc";
 328         bsf_name = "hevc_mp4toannexb";
 329
 330         ret = hevc_set_extradata(avctx, format);
 331         if (ret < 0)
 332             goto done;
 333         break;
 334 #endif
 335 #if CONFIG_MPEG4_MEDIACODEC_DECODER
 336     case AV_CODEC_ID_MPEG4:
 337         codec_mime = "video/mp4v-es",
 338
 339         ret = mpeg4_set_extradata(avctx, format);
 340         if (ret < 0)
 341             goto done;
 342         break;
 343 #endif
 344 #if CONFIG_VP8_MEDIACODEC_DECODER
 345     case AV_CODEC_ID_VP8:
 346         codec_mime = "video/x-vnd.on2.vp8";
 347
 348         ret = vpx_set_extradata(avctx, format);
 349         if (ret < 0)
 350             goto done;
 351         break;
 352 #endif
 353 #if CONFIG_VP9_MEDIACODEC_DECODER
 354     case AV_CODEC_ID_VP9:
 355         codec_mime = "video/x-vnd.on2.vp9";
 356
 357         ret = vpx_set_extradata(avctx, format);
 358         if (ret < 0)
 359             goto done;
 360         break;
 361 #endif
 362     default:
 363         av_assert0(0);
 364     }
 365
 366     ff_AMediaFormat_setString(format, "mime", codec_mime);
 367     ff_AMediaFormat_setInt32(format, "width", avctx->width);
 368     ff_AMediaFormat_setInt32(format, "height", avctx->height);
 369
 370     s->ctx = av_mallocz(sizeof(*s->ctx));
 371     if (!s->ctx) {
 372         av_log(avctx, AV_LOG_ERROR, "Failed to allocate MediaCodecDecContext\n");
 373         ret = AVERROR(ENOMEM);
 374         goto done;
 375     }
 376
 377     if ((ret = ff_mediacodec_dec_init(avctx, s->ctx, codec_mime, format)) < 0) {
 378         s->ctx = NULL;
 379         goto done;
 380     }
 381
 382     av_log(avctx, AV_LOG_INFO, "MediaCodec started successfully, ret = %d\n", ret);
 383
 384     s->fifo = av_fifo_alloc(sizeof(AVPacket));
 385     if (!s->fifo) {
 386         ret = AVERROR(ENOMEM);
 387         goto done;
 388     }
 389
 390     if (bsf_name) {
 391     bsf = av_bsf_get_by_name(bsf_name);
 392     if(!bsf) {
 393         ret = AVERROR_BSF_NOT_FOUND;
 394         goto done;
 395     }
 396
 397     if ((ret = av_bsf_alloc(bsf, &s->bsf))) {
 398         goto done;
 399     }
 400
 401     if (((ret = avcodec_parameters_from_context(s->bsf->par_in, avctx)) < 0) ||
 402         ((ret = av_bsf_init(s->bsf)) < 0)) {
 403           goto done;
 404     }
 405     }
 406
 407     av_init_packet(&s->filtered_pkt);
 408
 409 done:
 410     if (format) {
 411         ff_AMediaFormat_delete(format);
 412     }
 413
 414     if (ret < 0) {
 415         mediacodec_decode_close(avctx);
 416     }
 417
 418     return ret;
 419 }
 420
 421
 422 static int mediacodec_process_data(AVCodecContext *avctx, AVFrame *frame,
 423                                    int *got_frame, AVPacket *pkt)
 424 {
 425     MediaCodecH264DecContext *s = avctx->priv_data;
 426
 427     return ff_mediacodec_dec_decode(avctx, s->ctx, frame, got_frame, pkt);
 428 }
 429
 430 static int mediacodec_decode_frame(AVCodecContext *avctx, void *data,
 431                                    int *got_frame, AVPacket *avpkt)
 432 {
 433     MediaCodecH264DecContext *s = avctx->priv_data;
 434     AVFrame *frame    = data;
 435     int ret;
 436
 437     /* buffer the input packet */
 438     if (avpkt->size) {
 439         AVPacket input_pkt = { 0 };
 440
 441         if (av_fifo_space(s->fifo) < sizeof(input_pkt)) {
 442             ret = av_fifo_realloc2(s->fifo,
 443                                    av_fifo_size(s->fifo) + sizeof(input_pkt));
 444             if (ret < 0)
 445                 return ret;
 446         }
 447
 448         ret = av_packet_ref(&input_pkt, avpkt);
 449         if (ret < 0)
 450             return ret;
 451         av_fifo_generic_write(s->fifo, &input_pkt, sizeof(input_pkt), NULL);
 452     }
 453
 454     /*
 455      * MediaCodec.flush() discards both input and output buffers, thus we
 456      * need to delay the call to this function until the user has released or
 457      * renderered the frames he retains.
 458      *
 459      * After we have buffered an input packet, check if the codec is in the
 460      * flushing state. If it is, we need to call ff_mediacodec_dec_flush.
 461      *
 462      * ff_mediacodec_dec_flush returns 0 if the flush cannot be performed on
 463      * the codec (because the user retains frames). The codec stays in the
 464      * flushing state.
 465      *
 466      * ff_mediacodec_dec_flush returns 1 if the flush can actually be
 467      * performed on the codec. The codec leaves the flushing state and can
 468      * process again packets.
 469      *
 470      * ff_mediacodec_dec_flush returns a negative value if an error has
 471      * occurred.
 472      *
 473      */
 474     if (ff_mediacodec_dec_is_flushing(avctx, s->ctx)) {
 475         if (!ff_mediacodec_dec_flush(avctx, s->ctx)) {
 476             return avpkt->size;
 477         }
 478     }
 479
 480     /* process buffered data */
 481     while (!*got_frame) {
 482         /* prepare the input data -- convert to Annex B if needed */
 483         if (s->filtered_pkt.size <= 0) {
 484             AVPacket input_pkt = { 0 };
 485
 486             av_packet_unref(&s->filtered_pkt);
 487
 488             /* no more data */
 489             if (av_fifo_size(s->fifo) < sizeof(AVPacket)) {
 490                 return avpkt->size ? avpkt->size :
 491                     ff_mediacodec_dec_decode(avctx, s->ctx, frame, got_frame, avpkt);
 492             }
 493
 494             av_fifo_generic_read(s->fifo, &input_pkt, sizeof(input_pkt), NULL);
 495
 496             if (s->bsf) {
 497             ret = av_bsf_send_packet(s->bsf, &input_pkt);
 498             if (ret < 0) {
 499                 return ret;
 500             }
 501
 502             ret = av_bsf_receive_packet(s->bsf, &s->filtered_pkt);
 503             if (ret == AVERROR(EAGAIN)) {
 504                 goto done;
 505             }
 506             } else {
 507                 av_packet_move_ref(&s->filtered_pkt, &input_pkt);
 508             }
 509
 510             /* {h264,hevc}_mp4toannexb are used here and do not require flushing */
 511             av_assert0(ret != AVERROR_EOF);
 512
 513             if (ret < 0) {
 514                 return ret;
 515             }
 516         }
 517
 518         ret = mediacodec_process_data(avctx, frame, got_frame, &s->filtered_pkt);
 519         if (ret < 0)
 520             return ret;
 521
 522         s->filtered_pkt.size -= ret;
 523         s->filtered_pkt.data += ret;
 524     }
 525 done:
 526     return avpkt->size;
 527 }
 528
 529 static void mediacodec_decode_flush(AVCodecContext *avctx)
 530 {
 531     MediaCodecH264DecContext *s = avctx->priv_data;
 532
 533     while (av_fifo_size(s->fifo)) {
 534         AVPacket pkt;
 535         av_fifo_generic_read(s->fifo, &pkt, sizeof(pkt), NULL);
 536         av_packet_unref(&pkt);
 537     }
 538     av_fifo_reset(s->fifo);
 539
 540     av_packet_unref(&s->filtered_pkt);
 541
 542     ff_mediacodec_dec_flush(avctx, s->ctx);
 543 }
 544
 545 #if CONFIG_H264_MEDIACODEC_DECODER
 546 AVCodec ff_h264_mediacodec_decoder = {
 547     .name           = "h264_mediacodec",
 548     .long_name      = NULL_IF_CONFIG_SMALL("H.264 Android MediaCodec decoder"),
 549     .type           = AVMEDIA_TYPE_VIDEO,
 550     .id             = AV_CODEC_ID_H264,
 551     .priv_data_size = sizeof(MediaCodecH264DecContext),
 552     .init           = mediacodec_decode_init,
 553     .decode         = mediacodec_decode_frame,
 554     .flush          = mediacodec_decode_flush,
 555     .close          = mediacodec_decode_close,
 556     .capabilities   = CODEC_CAP_DELAY,
 557     .caps_internal  = FF_CODEC_CAP_SETS_PKT_DTS,
 558 };
 559 #endif
 560
 561 #if CONFIG_HEVC_MEDIACODEC_DECODER
 562 AVCodec ff_hevc_mediacodec_decoder = {
 563     .name           = "hevc_mediacodec",
 564     .long_name      = NULL_IF_CONFIG_SMALL("H.265 Android MediaCodec decoder"),
 565     .type           = AVMEDIA_TYPE_VIDEO,
 566     .id             = AV_CODEC_ID_HEVC,
 567     .priv_data_size = sizeof(MediaCodecH264DecContext),
 568     .init           = mediacodec_decode_init,
 569     .decode         = mediacodec_decode_frame,
 570     .flush          = mediacodec_decode_flush,
 571     .close          = mediacodec_decode_close,
 572     .capabilities   = CODEC_CAP_DELAY,
 573     .caps_internal  = FF_CODEC_CAP_SETS_PKT_DTS,
 574 };
 575 #endif
 576
 577 #if CONFIG_MPEG4_MEDIACODEC_DECODER
 578 AVCodec ff_mpeg4_mediacodec_decoder = {
 579     .name           = "mpeg4_mediacodec",
 580     .long_name      = NULL_IF_CONFIG_SMALL("MPEG-4 Android MediaCodec decoder"),
 581     .type           = AVMEDIA_TYPE_VIDEO,
 582     .id             = AV_CODEC_ID_MPEG4,
 583     .priv_data_size = sizeof(MediaCodecH264DecContext),
 584     .init           = mediacodec_decode_init,
 585     .decode         = mediacodec_decode_frame,
 586     .flush          = mediacodec_decode_flush,
 587     .close          = mediacodec_decode_close,
 588     .capabilities   = CODEC_CAP_DELAY,
 589     .caps_internal  = FF_CODEC_CAP_SETS_PKT_DTS,
 590 };
 591 #endif
 592
 593 #if CONFIG_VP8_MEDIACODEC_DECODER
 594 AVCodec ff_vp8_mediacodec_decoder = {
 595     .name           = "vp8_mediacodec",
 596     .long_name      = NULL_IF_CONFIG_SMALL("VP8 Android MediaCodec decoder"),
 597     .type           = AVMEDIA_TYPE_VIDEO,
 598     .id             = AV_CODEC_ID_VP8,
 599     .priv_data_size = sizeof(MediaCodecH264DecContext),
 600     .init           = mediacodec_decode_init,
 601     .decode         = mediacodec_decode_frame,
 602     .flush          = mediacodec_decode_flush,
 603     .close          = mediacodec_decode_close,
 604     .capabilities   = CODEC_CAP_DELAY,
 605     .caps_internal  = FF_CODEC_CAP_SETS_PKT_DTS,
 606 };
 607 #endif
 608
 609 #if CONFIG_VP9_MEDIACODEC_DECODER
 610 AVCodec ff_vp9_mediacodec_decoder = {
 611     .name           = "vp9_mediacodec",
 612     .long_name      = NULL_IF_CONFIG_SMALL("VP9 Android MediaCodec decoder"),
 613     .type           = AVMEDIA_TYPE_VIDEO,
 614     .id             = AV_CODEC_ID_VP9,
 615     .priv_data_size = sizeof(MediaCodecH264DecContext),
 616     .init           = mediacodec_decode_init,
 617     .decode         = mediacodec_decode_frame,
 618     .flush          = mediacodec_decode_flush,
 619     .close          = mediacodec_decode_close,
 620     .capabilities   = CODEC_CAP_DELAY,
 621     .caps_internal  = FF_CODEC_CAP_SETS_PKT_DTS,
 622 };
 623 #endif