lavc: add hevc mediacodec decoder
[ffmpeg.git] / libavcodec / mediacodecdec_h2645.c
1 /*
2  * Android MediaCodec H.264 / H.265 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 "mediacodecdec.h"
39 #include "mediacodec_wrapper.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 static int h2645_ps_to_nalu(const uint8_t *src, int src_size, uint8_t **out, int *out_size)
69 {
70     int i;
71     int ret = 0;
72     uint8_t *p = NULL;
73     static const uint8_t nalu_header[] = { 0x00, 0x00, 0x00, 0x01 };
74
75     if (!out || !out_size) {
76         return AVERROR(EINVAL);
77     }
78
79     p = av_malloc(sizeof(nalu_header) + src_size);
80     if (!p) {
81         return AVERROR(ENOMEM);
82     }
83
84     *out = p;
85     *out_size = sizeof(nalu_header) + src_size;
86
87     memcpy(p, nalu_header, sizeof(nalu_header));
88     memcpy(p + sizeof(nalu_header), src, src_size);
89
90     /* Escape 0x00, 0x00, 0x0{0-3} pattern */
91     for (i = 4; i < *out_size; i++) {
92         if (i < *out_size - 3 &&
93             p[i + 0] == 0 &&
94             p[i + 1] == 0 &&
95             p[i + 2] <= 3) {
96             uint8_t *new;
97
98             *out_size += 1;
99             new = av_realloc(*out, *out_size);
100             if (!new) {
101                 ret = AVERROR(ENOMEM);
102                 goto done;
103             }
104             *out = p = new;
105
106             i = i + 2;
107             memmove(p + i + 1, p + i, *out_size - (i + 1));
108             p[i] = 0x03;
109         }
110     }
111 done:
112     if (ret < 0) {
113         av_freep(out);
114         *out_size = 0;
115     }
116
117     return ret;
118 }
119
120 #if CONFIG_H264_MEDIACODEC_DECODER
121 static int h264_set_extradata(AVCodecContext *avctx, FFAMediaFormat *format)
122 {
123     int i;
124     int ret;
125
126     H264ParamSets ps;
127     const PPS *pps = NULL;
128     const SPS *sps = NULL;
129     int is_avc = 0;
130     int nal_length_size = 0;
131
132     memset(&ps, 0, sizeof(ps));
133
134     ret = ff_h264_decode_extradata(avctx->extradata, avctx->extradata_size,
135                                    &ps, &is_avc, &nal_length_size, 0, avctx);
136     if (ret < 0) {
137         goto done;
138     }
139
140     for (i = 0; i < MAX_PPS_COUNT; i++) {
141         if (ps.pps_list[i]) {
142             pps = (const PPS*)ps.pps_list[i]->data;
143             break;
144         }
145     }
146
147     if (pps) {
148         if (ps.sps_list[pps->sps_id]) {
149             sps = (const SPS*)ps.sps_list[pps->sps_id]->data;
150         }
151     }
152
153     if (pps && sps) {
154         uint8_t *data = NULL;
155         size_t data_size = 0;
156
157         if ((ret = h2645_ps_to_nalu(sps->data, sps->data_size, &data, &data_size)) < 0) {
158             goto done;
159         }
160         ff_AMediaFormat_setBuffer(format, "csd-0", (void*)data, data_size);
161         av_freep(&data);
162
163         if ((ret = h2645_ps_to_nalu(pps->data, pps->data_size, &data, &data_size)) < 0) {
164             goto done;
165         }
166         ff_AMediaFormat_setBuffer(format, "csd-1", (void*)data, data_size);
167         av_freep(&data);
168     } else {
169         av_log(avctx, AV_LOG_ERROR, "Could not extract PPS/SPS from extradata");
170         ret = AVERROR_INVALIDDATA;
171     }
172
173 done:
174     ff_h264_ps_uninit(&ps);
175
176     return ret;
177 }
178 #endif
179
180 #if CONFIG_HEVC_MEDIACODEC_DECODER
181 static int hevc_set_extradata(AVCodecContext *avctx, FFAMediaFormat *format)
182 {
183     int i;
184     int ret;
185
186     HEVCParamSets ps;
187
188     const HEVCVPS *vps = NULL;
189     const HEVCPPS *pps = NULL;
190     const HEVCSPS *sps = NULL;
191     int is_nalff = 0;
192     int nal_length_size = 0;
193
194     uint8_t *vps_data = NULL;
195     uint8_t *sps_data = NULL;
196     uint8_t *pps_data = NULL;
197     int vps_data_size = 0;
198     int sps_data_size = 0;
199     int pps_data_size = 0;
200
201     memset(&ps, 0, sizeof(ps));
202
203     ret = ff_hevc_decode_extradata(avctx->extradata, avctx->extradata_size,
204                                 &ps, &is_nalff, &nal_length_size, 0, avctx);
205     if (ret < 0) {
206         goto done;
207     }
208
209     for (i = 0; i < MAX_VPS_COUNT; i++) {
210         if (ps.vps_list[i]) {
211             vps = (const HEVCVPS*)ps.vps_list[i]->data;
212             break;
213         }
214     }
215
216     for (i = 0; i < MAX_PPS_COUNT; i++) {
217         if (ps.pps_list[i]) {
218             pps = (const HEVCPPS*)ps.pps_list[i]->data;
219             break;
220         }
221     }
222
223     if (pps) {
224         if (ps.sps_list[pps->sps_id]) {
225             sps = (const HEVCSPS*)ps.sps_list[pps->sps_id]->data;
226         }
227     }
228
229     if (vps && pps && sps) {
230         uint8_t *data;
231         int data_size;
232
233         if ((ret = h2645_ps_to_nalu(vps->data, vps->data_size, &vps_data, &vps_data_size)) < 0 ||
234             (ret = h2645_ps_to_nalu(sps->data, sps->data_size, &sps_data, &sps_data_size)) < 0 ||
235             (ret = h2645_ps_to_nalu(pps->data, pps->data_size, &pps_data, &pps_data_size)) < 0) {
236             goto done;
237         }
238
239         data_size = vps_data_size + sps_data_size + pps_data_size;
240         data = av_mallocz(data_size);
241         if (!data) {
242             ret = AVERROR(ENOMEM);
243             goto done;
244         }
245
246         memcpy(data                                , vps_data, vps_data_size);
247         memcpy(data + vps_data_size                , sps_data, sps_data_size);
248         memcpy(data + vps_data_size + sps_data_size, pps_data, pps_data_size);
249
250         ff_AMediaFormat_setBuffer(format, "csd-0", data, data_size);
251
252         av_freep(&data);
253     } else {
254         av_log(avctx, AV_LOG_ERROR, "Could not extract VPS/PPS/SPS from extradata");
255         ret = AVERROR_INVALIDDATA;
256     }
257
258 done:
259     av_freep(&vps_data);
260     av_freep(&sps_data);
261     av_freep(&pps_data);
262
263     return ret;
264 }
265 #endif
266
267 static av_cold int mediacodec_decode_init(AVCodecContext *avctx)
268 {
269     int ret;
270
271     const char *codec_mime = NULL;
272
273     const char *bsf_name = NULL;
274     const AVBitStreamFilter *bsf = NULL;
275
276     FFAMediaFormat *format = NULL;
277     MediaCodecH264DecContext *s = avctx->priv_data;
278
279     format = ff_AMediaFormat_new();
280     if (!format) {
281         av_log(avctx, AV_LOG_ERROR, "Failed to create media format\n");
282         ret = AVERROR_EXTERNAL;
283         goto done;
284     }
285
286     switch (avctx->codec_id) {
287 #if CONFIG_H264_MEDIACODEC_DECODER
288     case AV_CODEC_ID_H264:
289         codec_mime = "video/avc";
290         bsf_name = "h264_mp4toannexb";
291
292         ret = h264_set_extradata(avctx, format);
293         if (ret < 0)
294             goto done;
295         break;
296 #endif
297 #if CONFIG_HEVC_MEDIACODEC_DECODER
298     case AV_CODEC_ID_HEVC:
299         codec_mime = "video/hevc";
300         bsf_name = "hevc_mp4toannexb";
301
302         ret = hevc_set_extradata(avctx, format);
303         if (ret < 0)
304             goto done;
305         break;
306 #endif
307     default:
308         av_assert0(0);
309     }
310
311     ff_AMediaFormat_setString(format, "mime", codec_mime);
312     ff_AMediaFormat_setInt32(format, "width", avctx->width);
313     ff_AMediaFormat_setInt32(format, "height", avctx->height);
314
315     s->ctx = av_mallocz(sizeof(*s->ctx));
316     if (!s->ctx) {
317         av_log(avctx, AV_LOG_ERROR, "Failed to allocate MediaCodecDecContext\n");
318         ret = AVERROR(ENOMEM);
319         goto done;
320     }
321
322     if ((ret = ff_mediacodec_dec_init(avctx, s->ctx, codec_mime, format)) < 0) {
323         s->ctx = NULL;
324         goto done;
325     }
326
327     av_log(avctx, AV_LOG_INFO, "MediaCodec started successfully, ret = %d\n", ret);
328
329     s->fifo = av_fifo_alloc(sizeof(AVPacket));
330     if (!s->fifo) {
331         ret = AVERROR(ENOMEM);
332         goto done;
333     }
334
335     bsf = av_bsf_get_by_name(bsf_name);
336     if(!bsf) {
337         ret = AVERROR_BSF_NOT_FOUND;
338         goto done;
339     }
340
341     if ((ret = av_bsf_alloc(bsf, &s->bsf))) {
342         goto done;
343     }
344
345     if (((ret = avcodec_parameters_from_context(s->bsf->par_in, avctx)) < 0) ||
346         ((ret = av_bsf_init(s->bsf)) < 0)) {
347           goto done;
348     }
349
350     av_init_packet(&s->filtered_pkt);
351
352 done:
353     if (format) {
354         ff_AMediaFormat_delete(format);
355     }
356
357     if (ret < 0) {
358         mediacodec_decode_close(avctx);
359     }
360
361     return ret;
362 }
363
364
365 static int mediacodec_process_data(AVCodecContext *avctx, AVFrame *frame,
366                                    int *got_frame, AVPacket *pkt)
367 {
368     MediaCodecH264DecContext *s = avctx->priv_data;
369
370     return ff_mediacodec_dec_decode(avctx, s->ctx, frame, got_frame, pkt);
371 }
372
373 static int mediacodec_decode_frame(AVCodecContext *avctx, void *data,
374                                    int *got_frame, AVPacket *avpkt)
375 {
376     MediaCodecH264DecContext *s = avctx->priv_data;
377     AVFrame *frame    = data;
378     int ret;
379
380     /* buffer the input packet */
381     if (avpkt->size) {
382         AVPacket input_pkt = { 0 };
383
384         if (av_fifo_space(s->fifo) < sizeof(input_pkt)) {
385             ret = av_fifo_realloc2(s->fifo,
386                                    av_fifo_size(s->fifo) + sizeof(input_pkt));
387             if (ret < 0)
388                 return ret;
389         }
390
391         ret = av_packet_ref(&input_pkt, avpkt);
392         if (ret < 0)
393             return ret;
394         av_fifo_generic_write(s->fifo, &input_pkt, sizeof(input_pkt), NULL);
395     }
396
397     /*
398      * MediaCodec.flush() discards both input and output buffers, thus we
399      * need to delay the call to this function until the user has released or
400      * renderered the frames he retains.
401      *
402      * After we have buffered an input packet, check if the codec is in the
403      * flushing state. If it is, we need to call ff_mediacodec_dec_flush.
404      *
405      * ff_mediacodec_dec_flush returns 0 if the flush cannot be performed on
406      * the codec (because the user retains frames). The codec stays in the
407      * flushing state.
408      *
409      * ff_mediacodec_dec_flush returns 1 if the flush can actually be
410      * performed on the codec. The codec leaves the flushing state and can
411      * process again packets.
412      *
413      * ff_mediacodec_dec_flush returns a negative value if an error has
414      * occurred.
415      *
416      */
417     if (ff_mediacodec_dec_is_flushing(avctx, s->ctx)) {
418         if (!ff_mediacodec_dec_flush(avctx, s->ctx)) {
419             return avpkt->size;
420         }
421     }
422
423     /* process buffered data */
424     while (!*got_frame) {
425         /* prepare the input data -- convert to Annex B if needed */
426         if (s->filtered_pkt.size <= 0) {
427             AVPacket input_pkt = { 0 };
428
429             av_packet_unref(&s->filtered_pkt);
430
431             /* no more data */
432             if (av_fifo_size(s->fifo) < sizeof(AVPacket)) {
433                 return avpkt->size ? avpkt->size :
434                     ff_mediacodec_dec_decode(avctx, s->ctx, frame, got_frame, avpkt);
435             }
436
437             av_fifo_generic_read(s->fifo, &input_pkt, sizeof(input_pkt), NULL);
438
439             ret = av_bsf_send_packet(s->bsf, &input_pkt);
440             if (ret < 0) {
441                 return ret;
442             }
443
444             ret = av_bsf_receive_packet(s->bsf, &s->filtered_pkt);
445             if (ret == AVERROR(EAGAIN)) {
446                 goto done;
447             }
448
449             /* {h264,hevc}_mp4toannexb are used here and do not require flushing */
450             av_assert0(ret != AVERROR_EOF);
451
452             if (ret < 0) {
453                 return ret;
454             }
455         }
456
457         ret = mediacodec_process_data(avctx, frame, got_frame, &s->filtered_pkt);
458         if (ret < 0)
459             return ret;
460
461         s->filtered_pkt.size -= ret;
462         s->filtered_pkt.data += ret;
463     }
464 done:
465     return avpkt->size;
466 }
467
468 static void mediacodec_decode_flush(AVCodecContext *avctx)
469 {
470     MediaCodecH264DecContext *s = avctx->priv_data;
471
472     while (av_fifo_size(s->fifo)) {
473         AVPacket pkt;
474         av_fifo_generic_read(s->fifo, &pkt, sizeof(pkt), NULL);
475         av_packet_unref(&pkt);
476     }
477     av_fifo_reset(s->fifo);
478
479     av_packet_unref(&s->filtered_pkt);
480
481     ff_mediacodec_dec_flush(avctx, s->ctx);
482 }
483
484 #if CONFIG_H264_MEDIACODEC_DECODER
485 AVCodec ff_h264_mediacodec_decoder = {
486     .name           = "h264_mediacodec",
487     .long_name      = NULL_IF_CONFIG_SMALL("H.264 Android MediaCodec decoder"),
488     .type           = AVMEDIA_TYPE_VIDEO,
489     .id             = AV_CODEC_ID_H264,
490     .priv_data_size = sizeof(MediaCodecH264DecContext),
491     .init           = mediacodec_decode_init,
492     .decode         = mediacodec_decode_frame,
493     .flush          = mediacodec_decode_flush,
494     .close          = mediacodec_decode_close,
495     .capabilities   = CODEC_CAP_DELAY,
496     .caps_internal  = FF_CODEC_CAP_SETS_PKT_DTS,
497 };
498 #endif
499
500 #if CONFIG_HEVC_MEDIACODEC_DECODER
501 AVCodec ff_hevc_mediacodec_decoder = {
502     .name           = "hevc_mediacodec",
503     .long_name      = NULL_IF_CONFIG_SMALL("H.265 Android MediaCodec decoder"),
504     .type           = AVMEDIA_TYPE_VIDEO,
505     .id             = AV_CODEC_ID_HEVC,
506     .priv_data_size = sizeof(MediaCodecH264DecContext),
507     .init           = mediacodec_decode_init,
508     .decode         = mediacodec_decode_frame,
509     .flush          = mediacodec_decode_flush,
510     .close          = mediacodec_decode_close,
511     .capabilities   = CODEC_CAP_DELAY,
512     .caps_internal  = FF_CODEC_CAP_SETS_PKT_DTS,
513 };
514 #endif