#include "libavutil/atomic.h"
#include "avcodec.h"
-#include "h264.h"
+#include "h264dec.h"
#include "internal.h"
#include "mediacodecdec.h"
#include "mediacodec_wrapper.h"
typedef struct MediaCodecH264DecContext {
- MediaCodecDecContext ctx;
+ MediaCodecDecContext *ctx;
AVBSFContext *bsf;
{
MediaCodecH264DecContext *s = avctx->priv_data;
- ff_mediacodec_dec_close(avctx, &s->ctx);
+ ff_mediacodec_dec_close(avctx, s->ctx);
+ s->ctx = NULL;
av_fifo_free(s->fifo);
return 0;
}
+static int h264_ps_to_nalu(const uint8_t *src, int src_size, uint8_t **out, int *out_size)
+{
+ int i;
+ int ret = 0;
+ uint8_t *p = NULL;
+ static const uint8_t nalu_header[] = { 0x00, 0x00, 0x00, 0x01 };
+
+ if (!out || !out_size) {
+ return AVERROR(EINVAL);
+ }
+
+ p = av_malloc(sizeof(nalu_header) + src_size);
+ if (!p) {
+ return AVERROR(ENOMEM);
+ }
+
+ *out = p;
+ *out_size = sizeof(nalu_header) + src_size;
+
+ memcpy(p, nalu_header, sizeof(nalu_header));
+ memcpy(p + sizeof(nalu_header), src, src_size);
+
+ /* Escape 0x00, 0x00, 0x0{0-3} pattern */
+ for (i = 4; i < *out_size; i++) {
+ if (i < *out_size - 3 &&
+ p[i + 0] == 0 &&
+ p[i + 1] == 0 &&
+ p[i + 2] <= 3) {
+ uint8_t *new;
+
+ *out_size += 1;
+ new = av_realloc(*out, *out_size);
+ if (!new) {
+ ret = AVERROR(ENOMEM);
+ goto done;
+ }
+ *out = p = new;
+
+ i = i + 3;
+ memmove(p + i, p + i - 1, *out_size - i);
+ p[i - 1] = 0x03;
+ }
+ }
+done:
+ if (ret < 0) {
+ av_freep(out);
+ *out_size = 0;
+ }
+
+ return ret;
+}
+
static av_cold int mediacodec_decode_init(AVCodecContext *avctx)
{
int i;
}
if (pps && sps) {
- static const uint8_t nal_headers[] = { 0x00, 0x00, 0x00, 0x01 };
-
uint8_t *data = NULL;
- size_t data_size = sizeof(nal_headers) + FFMAX(sps->data_size, pps->data_size);
+ size_t data_size = 0;
- data = av_mallocz(data_size);
- if (!data) {
- ret = AVERROR(ENOMEM);
+ if ((ret = h264_ps_to_nalu(sps->data, sps->data_size, &data, &data_size)) < 0) {
goto done;
}
+ ff_AMediaFormat_setBuffer(format, "csd-0", (void*)data, data_size);
+ av_freep(&data);
- memcpy(data, nal_headers, sizeof(nal_headers));
- memcpy(data + sizeof(nal_headers), sps->data, sps->data_size);
- ff_AMediaFormat_setBuffer(format, "csd-0", (void*)data, sizeof(nal_headers) + sps->data_size);
-
- memcpy(data + sizeof(nal_headers), pps->data, pps->data_size);
- ff_AMediaFormat_setBuffer(format, "csd-1", (void*)data, sizeof(nal_headers) + pps->data_size);
-
+ if ((ret = h264_ps_to_nalu(pps->data, pps->data_size, &data, &data_size)) < 0) {
+ goto done;
+ }
+ ff_AMediaFormat_setBuffer(format, "csd-1", (void*)data, data_size);
av_freep(&data);
} else {
av_log(avctx, AV_LOG_ERROR, "Could not extract PPS/SPS from extradata");
goto done;
}
- if ((ret = ff_mediacodec_dec_init(avctx, &s->ctx, CODEC_MIME, format)) < 0) {
+ s->ctx = av_mallocz(sizeof(*s->ctx));
+ if (!s->ctx) {
+ av_log(avctx, AV_LOG_ERROR, "Failed to allocate MediaCodecDecContext\n");
+ ret = AVERROR(ENOMEM);
+ goto done;
+ }
+
+ if ((ret = ff_mediacodec_dec_init(avctx, s->ctx, CODEC_MIME, format)) < 0) {
+ s->ctx = NULL;
goto done;
}
{
MediaCodecH264DecContext *s = avctx->priv_data;
- return ff_mediacodec_dec_decode(avctx, &s->ctx, frame, got_frame, pkt);
+ return ff_mediacodec_dec_decode(avctx, s->ctx, frame, got_frame, pkt);
}
static int mediacodec_decode_frame(AVCodecContext *avctx, void *data,
av_fifo_generic_write(s->fifo, &input_pkt, sizeof(input_pkt), NULL);
}
+ /*
+ * MediaCodec.flush() discards both input and output buffers, thus we
+ * need to delay the call to this function until the user has released or
+ * renderered the frames he retains.
+ *
+ * After we have buffered an input packet, check if the codec is in the
+ * flushing state. If it is, we need to call ff_mediacodec_dec_flush.
+ *
+ * ff_mediacodec_dec_flush returns 0 if the flush cannot be performed on
+ * the codec (because the user retains frames). The codec stays in the
+ * flushing state.
+ *
+ * ff_mediacodec_dec_flush returns 1 if the flush can actually be
+ * performed on the codec. The codec leaves the flushing state and can
+ * process again packets.
+ *
+ * ff_mediacodec_dec_flush returns a negative value if an error has
+ * occurred.
+ *
+ */
+ if (ff_mediacodec_dec_is_flushing(avctx, s->ctx)) {
+ if (!ff_mediacodec_dec_flush(avctx, s->ctx)) {
+ return avpkt->size;
+ }
+ }
+
/* process buffered data */
while (!*got_frame) {
/* prepare the input data -- convert to Annex B if needed */
/* no more data */
if (av_fifo_size(s->fifo) < sizeof(AVPacket)) {
return avpkt->size ? avpkt->size :
- ff_mediacodec_dec_decode(avctx, &s->ctx, frame, got_frame, avpkt);
+ ff_mediacodec_dec_decode(avctx, s->ctx, frame, got_frame, avpkt);
}
av_fifo_generic_read(s->fifo, &input_pkt, sizeof(input_pkt), NULL);
av_packet_unref(&s->filtered_pkt);
- ff_mediacodec_dec_flush(avctx, &s->ctx);
+ ff_mediacodec_dec_flush(avctx, s->ctx);
}
AVCodec ff_h264_mediacodec_decoder = {