int ff_mediacodec_dec_decode(AVCodecContext *avctx, MediaCodecDecContext *s,
AVFrame *frame, int *got_frame,
AVPacket *pkt)
{
int ret;
int offset = 0;
int need_flushing = 0;
uint8_t *data;
ssize_t index;
size_t size;
FFAMediaCodec *codec = s->codec;
FFAMediaCodecBufferInfo info = { 0 };
int status;
int64_t input_dequeue_timeout_us = INPUT_DEQUEUE_TIMEOUT_US;
int64_t output_dequeue_timeout_us = OUTPUT_DEQUEUE_TIMEOUT_US;
if (pkt->size == 0) {
need_flushing = 1;
}
if (s->flushing && need_flushing && s->queued_buffer_nb <= 0) {
return 0;
}
while (offset < pkt->size || (need_flushing && !s->flushing)) {
int size;
index = ff_AMediaCodec_dequeueInputBuffer(codec, input_dequeue_timeout_us);
if (ff_AMediaCodec_infoTryAgainLater(codec, index)) {
break;
}
if (index < 0) {
av_log(avctx, AV_LOG_ERROR, "Failed to dequeue input buffer (status=%zd)\n", index);
return AVERROR_EXTERNAL;
}
data = ff_AMediaCodec_getInputBuffer(codec, index, &size);
if (!data) {
av_log(avctx, AV_LOG_ERROR, "Failed to get input buffer\n");
return AVERROR_EXTERNAL;
}
if (need_flushing) {
uint32_t flags = ff_AMediaCodec_getBufferFlagEndOfStream(codec);
av_log(avctx, AV_LOG_DEBUG, "Sending End Of Stream signal\n");
status = ff_AMediaCodec_queueInputBuffer(codec, index, 0, 0, pkt->pts, flags);
if (status < 0) {
av_log(avctx, AV_LOG_ERROR, "Failed to queue input empty buffer (status = %d)\n", status);
return AVERROR_EXTERNAL;
}
s->flushing = 1;
break;
} else {
size = FFMIN(pkt->size - offset, size);
memcpy(data, pkt->data + offset, size);
offset += size;
status = ff_AMediaCodec_queueInputBuffer(codec, index, 0, size, pkt->pts, 0);
if (status < 0) {
av_log(avctx, AV_LOG_ERROR, "Failed to queue input buffer (status = %d)\n", status);
return AVERROR_EXTERNAL;
}
s->queued_buffer_nb++;
if (s->queued_buffer_nb > s->queued_buffer_max)
s->queued_buffer_max = s->queued_buffer_nb;
}
}
if (s->flushing) {
/* If the codec is flushing, block for a fair amount of time to
* ensure we got a frame */
output_dequeue_timeout_us = OUTPUT_DEQUEUE_BLOCK_TIMEOUT_US;
} else if (s->dequeued_buffer_nb == 0) {
/* If the codec hasn't produced any frames, do not block so we
* can push data to it as fast as possible, and get the first
* frame */
output_dequeue_timeout_us = 0;
}
index = ff_AMediaCodec_dequeueOutputBuffer(codec, &info, output_dequeue_timeout_us);
if (index >= 0) {
int ret;
if (!s->first_buffer++) {
av_log(avctx, AV_LOG_DEBUG, "Got first buffer after %fms\n", (av_gettime() - s->first_buffer_at) / 1000);
}
av_log(avctx, AV_LOG_DEBUG, "Got output buffer %zd"
" offset=%" PRIi32 " size=%" PRIi32 " ts=%" PRIi64
" flags=%" PRIu32 "\n", index, info.offset, info.size,
info.presentationTimeUs, info.flags);
data = ff_AMediaCodec_getOutputBuffer(codec, index, &size);
if (!data) {
av_log(avctx, AV_LOG_ERROR, "Failed to get output buffer\n");
return AVERROR_EXTERNAL;
}
if ((ret = mediacodec_wrap_buffer(avctx, s, data, size, index, &info, frame)) < 0) {
av_log(avctx, AV_LOG_ERROR, "Failed to wrap MediaCodec buffer\n");
return ret;
}
*got_frame = 1;
s->queued_buffer_nb--;
s->dequeued_buffer_nb++;
} else if (ff_AMediaCodec_infoOutputFormatChanged(codec, index)) {
char *format = NULL;
if (s->format) {
status = ff_AMediaFormat_delete(s->format);
if (status < 0) {
av_log(avctx, AV_LOG_ERROR, "Failed to delete MediaFormat %p\n", s->format);
}
}
s->format = ff_AMediaCodec_getOutputFormat(codec);
if (!s->format) {
av_log(avctx, AV_LOG_ERROR, "Failed to get output format\n");
return AVERROR_EXTERNAL;
}
format = ff_AMediaFormat_toString(s->format);
if (!format) {
return AVERROR_EXTERNAL;
}
av_log(avctx, AV_LOG_INFO, "Output MediaFormat changed to %s\n", format);
av_freep(&format);
if ((ret = mediacodec_dec_parse_format(avctx, s)) < 0) {
return ret;
}
} else if (ff_AMediaCodec_infoOutputBuffersChanged(codec, index)) {
ff_AMediaCodec_cleanOutputBuffers(codec);
} else if (ff_AMediaCodec_infoTryAgainLater(codec, index)) {
if (s->flushing) {
av_log(avctx, AV_LOG_ERROR, "Failed to dequeue output buffer within %" PRIi64 "ms "
"while flushing remaining frames, output will probably lack last %d frames\n",
output_dequeue_timeout_us / 1000, s->queued_buffer_nb);
} else {
av_log(avctx, AV_LOG_DEBUG, "No output buffer available, try again later\n");
}
} else {
av_log(avctx, AV_LOG_ERROR, "Failed to dequeue output buffer (status=%zd)\n", index);
return AVERROR_EXTERNAL;
}
return offset;
}
int ff_mediacodec_dec_send(AVCodecContext *avctx, MediaCodecDecContext *s,
AVPacket *pkt)
{
int offset = 0;
int need_draining = 0;
uint8_t *data;
ssize_t index;
size_t size;
FFAMediaCodec *codec = s->codec;
int status;
int64_t input_dequeue_timeout_us = INPUT_DEQUEUE_TIMEOUT_US;
if (s->flushing) {
av_log(avctx, AV_LOG_ERROR, "Decoder is flushing and cannot accept new buffer "
"until all output buffers have been released\n");
return AVERROR_EXTERNAL;
}
if (pkt->size == 0) {
need_draining = 1;
}
if (s->draining && s->eos) {
return AVERROR_EOF;
}
while (offset < pkt->size || (need_draining && !s->draining)) {
index = ff_AMediaCodec_dequeueInputBuffer(codec, input_dequeue_timeout_us);
if (ff_AMediaCodec_infoTryAgainLater(codec, index)) {
av_log(avctx, AV_LOG_TRACE, "No input buffer available, try again later\n");
break;
}
if (index < 0) {
av_log(avctx, AV_LOG_ERROR, "Failed to dequeue input buffer (status=%zd)\n", index);
return AVERROR_EXTERNAL;
}
data = ff_AMediaCodec_getInputBuffer(codec, index, &size);
if (!data) {
av_log(avctx, AV_LOG_ERROR, "Failed to get input buffer\n");
return AVERROR_EXTERNAL;
}
if (need_draining) {
int64_t pts = pkt->pts;
uint32_t flags = ff_AMediaCodec_getBufferFlagEndOfStream(codec);
if (s->surface) {
pts = av_rescale_q(pts, avctx->pkt_timebase, av_make_q(1, 1000000));
}
av_log(avctx, AV_LOG_DEBUG, "Sending End Of Stream signal\n");
status = ff_AMediaCodec_queueInputBuffer(codec, index, 0, 0, pts, flags);
if (status < 0) {
av_log(avctx, AV_LOG_ERROR, "Failed to queue input empty buffer (status = %d)\n", status);
return AVERROR_EXTERNAL;
}
av_log(avctx, AV_LOG_TRACE,
"Queued input buffer %zd size=%zd ts=%"PRIi64"\n", index, size, pts);
s->draining = 1;
break;
} else {
int64_t pts = pkt->pts;
size = FFMIN(pkt->size - offset, size);
memcpy(data, pkt->data + offset, size);
offset += size;
if (avctx->pkt_timebase.num && avctx->pkt_timebase.den) {
pts = av_rescale_q(pts, avctx->pkt_timebase, av_make_q(1, 1000000));
}
status = ff_AMediaCodec_queueInputBuffer(codec, index, 0, size, pts, 0);
if (status < 0) {
av_log(avctx, AV_LOG_ERROR, "Failed to queue input buffer (status = %d)\n", status);
return AVERROR_EXTERNAL;
}
av_log(avctx, AV_LOG_TRACE,
"Queued input buffer %zd size=%zd ts=%"PRIi64"\n", index, size, pts);
}
}
if (offset == 0)
return AVERROR(EAGAIN);
return offset;
}