@@ -29,16 +29,18 @@
#include "avcodec.h"
#include "internal.h"
#include "get_bits.h"
+#include "libavutil/ancillary_data.h"
#include "libavutil/imgutils.h"
struct BitpackedContext {
- int (*decode)(AVCodecContext *avctx, AVFrame *frame,
- AVPacket *pkt);
+ int (*decode)(AVCodecContext *avctx, AVFrame *frame, AVPacket *pkt, uint8_t field);
+ AVFrame *cur_interlaced_frame;
+ int prev_top_field;
};
/* For this format, it's a simple passthrough */
static int bitpacked_decode_uyvy422(AVCodecContext *avctx, AVFrame *frame,
- AVPacket *avpkt)
+ AVPacket *avpkt, uint8_t field)
{
int ret;
@@ -56,29 +58,43 @@ static int bitpacked_decode_uyvy422(AVCodecContext *avctx, AVFrame *frame,
}
static int bitpacked_decode_yuv422p10(AVCodecContext *avctx, AVFrame *frame,
- AVPacket *avpkt)
+ AVPacket *avpkt, uint8_t field)
{
- uint64_t frame_size = (uint64_t)avctx->width * (uint64_t)avctx->height * 20;
+ uint64_t frame_size = avctx->width * avctx->height * 20LL;
uint64_t packet_size = (uint64_t)avpkt->size * 8;
+ int interlaced = frame->interlaced_frame;
+ int top_field = (field & AV_ANCILLARY_DATA_FIELD_TOP_FIELD) ? 1 : 0;
GetBitContext bc;
uint16_t *y, *u, *v;
int ret, i, j;
- ret = ff_get_buffer(avctx, frame, 0);
- if (ret < 0)
- return ret;
-
- if (frame_size > packet_size)
+ /* check packet size depending on the interlaced/progressive format */
+ if (interlaced) {
+ if ((frame_size / 2) > packet_size)
+ return AVERROR_INVALIDDATA;
+ } else if (frame_size > packet_size) {
return AVERROR_INVALIDDATA;
+ }
if (avctx->width % 2)
return AVERROR_PATCHWELCOME;
- ret = init_get_bits(&bc, avpkt->data, avctx->width * avctx->height * 20);
+ /*
+ * if the frame is interlaced, the avpkt we are getting is either the top
+ * or the bottom field. If it's the bottom field, it contains all the odd
+ * lines of the recomposed frame, so we start at offset 1.
+ */
+ i = (interlaced && !top_field) ? 1 : 0;
+
+ ret = init_get_bits(&bc, avpkt->data, frame_size);
if (ret)
return ret;
- for (i = 0; i < avctx->height; i++) {
+ /*
+ * Packets from interlaced frames contain either even lines, or odd
+ * lines, so increment by two in that case.
+ */
+ for (; i < avctx->height; i += 1 + interlaced) {
y = (uint16_t*)(frame->data[0] + i * frame->linesize[0]);
u = (uint16_t*)(frame->data[1] + i * frame->linesize[1]);
v = (uint16_t*)(frame->data[2] + i * frame->linesize[2]);
@@ -103,17 +119,35 @@ static av_cold int bitpacked_init_decoder(AVCodecContext *avctx)
if (avctx->codec_tag == MKTAG('U', 'Y', 'V', 'Y')) {
if (avctx->bits_per_coded_sample == 16 &&
- avctx->pix_fmt == AV_PIX_FMT_UYVY422)
+ avctx->pix_fmt == AV_PIX_FMT_UYVY422) {
+
+ if (avctx->field_order > AV_FIELD_PROGRESSIVE) {
+ av_log(avctx, AV_LOG_ERROR, "interlaced not yet supported for 8-bit\n");
+ return AVERROR_PATCHWELCOME;
+ }
+
bc->decode = bitpacked_decode_uyvy422;
- else if (avctx->bits_per_coded_sample == 20 &&
- avctx->pix_fmt == AV_PIX_FMT_YUV422P10)
+ } else if (avctx->bits_per_coded_sample == 20 &&
+ avctx->pix_fmt == AV_PIX_FMT_YUV422P10) {
bc->decode = bitpacked_decode_yuv422p10;
- else
+ } else {
return AVERROR_INVALIDDATA;
+ }
} else {
return AVERROR_INVALIDDATA;
}
+ bc->cur_interlaced_frame = av_frame_alloc();
+
+ return 0;
+}
+
+static av_cold int bitpacked_end_decoder(AVCodecContext *avctx)
+{
+ struct BitpackedContext *bc = avctx->priv_data;
+
+ av_frame_free(&bc->cur_interlaced_frame);
+
return 0;
}
@@ -121,20 +155,79 @@ static int bitpacked_decode(AVCodecContext *avctx, void *data, int *got_frame,
AVPacket *avpkt)
{
struct BitpackedContext *bc = avctx->priv_data;
+ AVAncillaryData * ancillary;
int buf_size = avpkt->size;
AVFrame *frame = data;
- int res;
+ int res, size;
+ uint8_t * side_data;
+ uint8_t field;
frame->pict_type = AV_PICTURE_TYPE_I;
frame->key_frame = 1;
- res = bc->decode(avctx, frame, avpkt);
- if (res)
- return res;
+ side_data = av_packet_get_side_data(avpkt, AV_PKT_DATA_ANCILLARY, &size);
+ if (side_data) {
+ ancillary = (AVAncillaryData*)(side_data);
+ field = ancillary->field;
+ }
- *got_frame = 1;
- return buf_size;
+ if ((field & AV_ANCILLARY_DATA_FIELD_TOP_FIELD) &&
+ (field & AV_ANCILLARY_DATA_FIELD_BOTTOM_FIELD)) {
+ av_log(avctx, AV_LOG_WARNING, "Invalid field flags.\n");
+ return AVERROR_INVALIDDATA;
+ } else if (field & AV_ANCILLARY_DATA_FIELD_TOP_FIELD) {
+ frame->interlaced_frame = 1;
+ frame->top_field_first = 1;
+
+ if((res = ff_get_buffer(avctx, frame, 0)) < 0)
+ return res;
+
+ /* always decode the top (1st) field and ref the result frame
+ * but don't output anything */
+ if ((res = bc->decode(avctx, frame, avpkt, field)) < 0)
+ return res;
+
+ av_frame_unref(bc->cur_interlaced_frame);
+ if ((res = av_frame_ref(bc->cur_interlaced_frame, frame)) < 0)
+ return res;
+
+ bc->prev_top_field = 1;
+
+ return 0;
+ } else if (field & AV_ANCILLARY_DATA_FIELD_BOTTOM_FIELD) {
+ if (!bc->prev_top_field) {
+ av_log(avctx, AV_LOG_ERROR, "Top field missing.\n");
+ return AVERROR_INVALIDDATA;
+ }
+ frame->interlaced_frame = 1;
+ frame->top_field_first = 1;
+
+ /* complete the ref'd frame with bottom field and output the
+ * result */
+ if ((res = bc->decode(avctx, bc->cur_interlaced_frame, avpkt, field)) < 0)
+ return res;
+
+ if ((res = av_frame_ref(frame, bc->cur_interlaced_frame)) < 0)
+ return res;
+
+ bc->prev_top_field = 0;
+ *got_frame = 1;
+ return buf_size;
+ } else {
+ /* No field: the frame is progressive. */
+ if (bc->prev_top_field)
+ av_frame_unref(bc->cur_interlaced_frame);
+
+ if((res = ff_get_buffer(avctx, frame, 0)) < 0)
+ return res;
+
+ if ((res = bc->decode(avctx, frame, avpkt, field)) < 0)
+ return res;
+
+ *got_frame = 1;
+ return buf_size;
+ }
}
AVCodec ff_bitpacked_decoder = {
@@ -144,6 +237,7 @@ AVCodec ff_bitpacked_decoder = {
.id = AV_CODEC_ID_BITPACKED,
.priv_data_size = sizeof(struct BitpackedContext),
.init = bitpacked_init_decoder,
+ .close = bitpacked_end_decoder,
.decode = bitpacked_decode,
.capabilities = AV_CODEC_CAP_EXPERIMENTAL,
};