lavc: add h264 mediacodec decoder
[ffmpeg.git] / libavcodec / mediacodecdec_h264.c
1 /*
2  * Android MediaCodec H.264 decoder
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/common.h"
27 #include "libavutil/fifo.h"
28 #include "libavutil/opt.h"
29 #include "libavutil/intreadwrite.h"
30 #include "libavutil/pixfmt.h"
31 #include "libavutil/atomic.h"
32
33 #include "avcodec.h"
34 #include "internal.h"
35 #include "mediacodecdec.h"
36 #include "mediacodec_wrapper.h"
37
38 #define CODEC_MIME "video/avc"
39
40 typedef struct MediaCodecH264DecContext {
41
42     MediaCodecDecContext ctx;
43
44     AVBitStreamFilterContext *bsf;
45
46     AVFifoBuffer *fifo;
47
48     AVPacket input_ref;
49     AVPacket filtered_pkt;
50     uint8_t *filtered_data;
51
52 } MediaCodecH264DecContext;
53
54 static int h264_extradata_to_annexb_sps_pps(AVCodecContext *avctx,
55         uint8_t **extradata_annexb, int *extradata_annexb_size,
56         int *sps_offset, int *sps_size,
57         int *pps_offset, int *pps_size)
58 {
59     uint16_t unit_size;
60     uint64_t total_size = 0;
61
62     uint8_t i, j, unit_nb;
63     uint8_t sps_seen = 0;
64     uint8_t pps_seen = 0;
65
66     const uint8_t *extradata;
67     static const uint8_t nalu_header[4] = { 0x00, 0x00, 0x00, 0x01 };
68
69     if (avctx->extradata_size < 8) {
70         av_log(avctx, AV_LOG_ERROR,
71             "Too small extradata size, corrupted stream or invalid MP4/AVCC bitstream\n");
72         return AVERROR(EINVAL);
73     }
74
75     *extradata_annexb = NULL;
76     *extradata_annexb_size = 0;
77
78     *sps_offset = *sps_size = 0;
79     *pps_offset = *pps_size = 0;
80
81     extradata = avctx->extradata + 4;
82
83     /* skip length size */
84     extradata++;
85
86     for (j = 0; j < 2; j ++) {
87
88         if (j == 0) {
89             /* number of sps unit(s) */
90             unit_nb = *extradata++ & 0x1f;
91         } else {
92             /* number of pps unit(s) */
93             unit_nb = *extradata++;
94         }
95
96         for (i = 0; i < unit_nb; i++) {
97             int err;
98
99             unit_size   = AV_RB16(extradata);
100             total_size += unit_size + 4;
101
102             if (total_size > INT_MAX) {
103                 av_log(avctx, AV_LOG_ERROR,
104                     "Too big extradata size, corrupted stream or invalid MP4/AVCC bitstream\n");
105                 av_freep(extradata_annexb);
106                 return AVERROR(EINVAL);
107             }
108
109             if (extradata + 2 + unit_size > avctx->extradata + avctx->extradata_size) {
110                 av_log(avctx, AV_LOG_ERROR, "Packet header is not contained in global extradata, "
111                     "corrupted stream or invalid MP4/AVCC bitstream\n");
112                 av_freep(extradata_annexb);
113                 return AVERROR(EINVAL);
114             }
115
116             if ((err = av_reallocp(extradata_annexb, total_size)) < 0) {
117                 return err;
118             }
119
120             memcpy(*extradata_annexb + total_size - unit_size - 4, nalu_header, 4);
121             memcpy(*extradata_annexb + total_size - unit_size, extradata + 2, unit_size);
122             extradata += 2 + unit_size;
123         }
124
125         if (unit_nb) {
126             if (j == 0) {
127                 sps_seen = 1;
128                 *sps_size = total_size;
129             } else {
130                 pps_seen = 1;
131                 *pps_size = total_size - *sps_size;
132                 *pps_offset = *sps_size;
133             }
134         }
135     }
136
137     *extradata_annexb_size = total_size;
138
139     if (!sps_seen)
140         av_log(avctx, AV_LOG_WARNING,
141                "Warning: SPS NALU missing or invalid. "
142                "The resulting stream may not play.\n");
143
144     if (!pps_seen)
145         av_log(avctx, AV_LOG_WARNING,
146                "Warning: PPS NALU missing or invalid. "
147                "The resulting stream may not play.\n");
148
149     return 0;
150 }
151
152 static av_cold int mediacodec_decode_close(AVCodecContext *avctx)
153 {
154     MediaCodecH264DecContext *s = avctx->priv_data;
155
156     ff_mediacodec_dec_close(avctx, &s->ctx);
157
158     av_fifo_free(s->fifo);
159
160     av_bitstream_filter_close(s->bsf);
161
162     return 0;
163 }
164
165 static av_cold int mediacodec_decode_init(AVCodecContext *avctx)
166 {
167     int ret;
168     FFAMediaFormat *format = NULL;
169     MediaCodecH264DecContext *s = avctx->priv_data;
170
171     format = ff_AMediaFormat_new();
172     if (!format) {
173         av_log(avctx, AV_LOG_ERROR, "Failed to create media format\n");
174         ret = AVERROR_EXTERNAL;
175         goto done;
176     }
177
178     ff_AMediaFormat_setString(format, "mime", CODEC_MIME);
179     ff_AMediaFormat_setInt32(format, "width", avctx->width);
180     ff_AMediaFormat_setInt32(format, "height", avctx->height);
181
182     if (avctx->extradata[0] == 1) {
183         uint8_t *extradata = NULL;
184         int extradata_size = 0;
185
186         int sps_offset, sps_size;
187         int pps_offset, pps_size;
188
189         if ((ret = h264_extradata_to_annexb_sps_pps(avctx, &extradata, &extradata_size,
190                 &sps_offset, &sps_size, &pps_offset, &pps_size)) < 0) {
191             goto done;
192         }
193
194         ff_AMediaFormat_setBuffer(format, "csd-0", extradata + sps_offset, sps_size);
195         ff_AMediaFormat_setBuffer(format, "csd-1", extradata + pps_offset, pps_size);
196
197         av_freep(&extradata);
198     } else {
199         ff_AMediaFormat_setBuffer(format, "csd-0", avctx->extradata, avctx->extradata_size);
200     }
201
202     if ((ret = ff_mediacodec_dec_init(avctx, &s->ctx, CODEC_MIME, format)) < 0) {
203         goto done;
204     }
205
206     av_log(avctx, AV_LOG_INFO, "MediaCodec started successfully, ret = %d\n", ret);
207
208     s->fifo = av_fifo_alloc(sizeof(AVPacket));
209     if (!s->fifo) {
210         ret = AVERROR(ENOMEM);
211         goto done;
212     }
213
214     s->bsf = av_bitstream_filter_init("h264_mp4toannexb");
215     if (!s->bsf) {
216         ret = AVERROR(ENOMEM);
217         goto done;
218     }
219
220 done:
221     if (format) {
222         ff_AMediaFormat_delete(format);
223     }
224
225     if (ret < 0) {
226         mediacodec_decode_close(avctx);
227     }
228     return ret;
229 }
230
231
232 static int mediacodec_process_data(AVCodecContext *avctx, AVFrame *frame,
233                                    int *got_frame, AVPacket *pkt)
234 {
235     MediaCodecH264DecContext *s = avctx->priv_data;
236
237     return ff_mediacodec_dec_decode(avctx, &s->ctx, frame, got_frame, pkt);
238 }
239
240 static int mediacodec_decode_frame(AVCodecContext *avctx, void *data,
241                                    int *got_frame, AVPacket *avpkt)
242 {
243     MediaCodecH264DecContext *s = avctx->priv_data;
244     AVFrame *frame    = data;
245     int ret;
246
247     /* buffer the input packet */
248     if (avpkt->size) {
249         AVPacket input_ref = { 0 };
250
251         if (av_fifo_space(s->fifo) < sizeof(input_ref)) {
252             ret = av_fifo_realloc2(s->fifo,
253                                    av_fifo_size(s->fifo) + sizeof(input_ref));
254             if (ret < 0)
255                 return ret;
256         }
257
258         ret = av_packet_ref(&input_ref, avpkt);
259         if (ret < 0)
260             return ret;
261         av_fifo_generic_write(s->fifo, &input_ref, sizeof(input_ref), NULL);
262     }
263
264     /* process buffered data */
265     while (!*got_frame) {
266         /* prepare the input data -- convert to Annex B if needed */
267         if (s->filtered_pkt.size <= 0) {
268             int size;
269
270             /* no more data */
271             if (av_fifo_size(s->fifo) < sizeof(AVPacket)) {
272                 return avpkt->size ? avpkt->size :
273                     ff_mediacodec_dec_decode(avctx, &s->ctx, frame, got_frame, avpkt);
274             }
275
276             if (s->filtered_data != s->input_ref.data)
277                 av_freep(&s->filtered_data);
278             s->filtered_data = NULL;
279             av_packet_unref(&s->input_ref);
280
281             av_fifo_generic_read(s->fifo, &s->input_ref, sizeof(s->input_ref), NULL);
282             ret = av_bitstream_filter_filter(s->bsf, avctx, NULL,
283                                              &s->filtered_data, &size,
284                                              s->input_ref.data, s->input_ref.size, 0);
285             if (ret < 0) {
286                 s->filtered_data = s->input_ref.data;
287                 size             = s->input_ref.size;
288             }
289             s->filtered_pkt      = s->input_ref;
290             s->filtered_pkt.data = s->filtered_data;
291             s->filtered_pkt.size = size;
292         }
293
294         ret = mediacodec_process_data(avctx, frame, got_frame, &s->filtered_pkt);
295         if (ret < 0)
296             return ret;
297
298         s->filtered_pkt.size -= ret;
299         s->filtered_pkt.data += ret;
300     }
301
302     return avpkt->size;
303 }
304
305 static void mediacodec_decode_flush(AVCodecContext *avctx)
306 {
307     MediaCodecH264DecContext *s = avctx->priv_data;
308
309     while (av_fifo_size(s->fifo)) {
310         AVPacket pkt;
311         av_fifo_generic_read(s->fifo, &pkt, sizeof(pkt), NULL);
312         av_packet_unref(&pkt);
313     }
314     av_fifo_reset(s->fifo);
315
316     av_packet_unref(&s->input_ref);
317
318     av_init_packet(&s->filtered_pkt);
319     s->filtered_pkt.data = NULL;
320     s->filtered_pkt.size = 0;
321
322     ff_mediacodec_dec_flush(avctx, &s->ctx);
323 }
324
325 AVCodec ff_h264_mediacodec_decoder = {
326     .name           = "h264_mediacodec",
327     .long_name      = NULL_IF_CONFIG_SMALL("H.264 Android MediaCodec decoder"),
328     .type           = AVMEDIA_TYPE_VIDEO,
329     .id             = AV_CODEC_ID_H264,
330     .priv_data_size = sizeof(MediaCodecH264DecContext),
331     .init           = mediacodec_decode_init,
332     .decode         = mediacodec_decode_frame,
333     .flush          = mediacodec_decode_flush,
334     .close          = mediacodec_decode_close,
335     .capabilities   = CODEC_CAP_DELAY,
336 };