path: root/libavcodec/v210dec.c (plain)
blob: 9af9af67972c12fc8d2ad3025e6321da4305e696

1	/*
2	* V210 decoder
3	*
4	* Copyright (C) 2009 Michael Niedermayer <michaelni@gmx.at>
5	* Copyright (c) 2009 Baptiste Coudurier <baptiste dot coudurier at gmail dot com>
6	*
7	* This file is part of FFmpeg.
8	*
9	* FFmpeg is free software; you can redistribute it and/or
10	* modify it under the terms of the GNU Lesser General Public
11	* License as published by the Free Software Foundation; either
12	* version 2.1 of the License, or (at your option) any later version.
13	*
14	* FFmpeg is distributed in the hope that it will be useful,
15	* but WITHOUT ANY WARRANTY; without even the implied warranty of
16	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17	* Lesser General Public License for more details.
18	*
19	* You should have received a copy of the GNU Lesser General Public
20	* License along with FFmpeg; if not, write to the Free Software
21	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22	*/
23
24	#include "avcodec.h"
25	#include "internal.h"
26	#include "v210dec.h"
27	#include "libavutil/bswap.h"
28	#include "libavutil/internal.h"
29	#include "libavutil/mem.h"
30
31	#define READ_PIXELS(a, b, c) \
32	do { \
33	val = av_le2ne32(*src++); \
34	*a++ = val & 0x3FF; \
35	*b++ = (val >> 10) & 0x3FF; \
36	*c++ = (val >> 20) & 0x3FF; \
37	} while (0)
38
39	static void v210_planar_unpack_c(const uint32_t *src, uint16_t *y, uint16_t *u, uint16_t *v, int width)
40	{
41	uint32_t val;
42	int i;
43
44	for( i = 0; i < width-5; i += 6 ){
45	READ_PIXELS(u, y, v);
46	READ_PIXELS(y, u, y);
47	READ_PIXELS(v, y, u);
48	READ_PIXELS(y, v, y);
49	}
50	}
51
52	static av_cold int decode_init(AVCodecContext *avctx)
53	{
54	V210DecContext *s = avctx->priv_data;
55
56	avctx->pix_fmt = AV_PIX_FMT_YUV422P10;
57	avctx->bits_per_raw_sample = 10;
58
59	s->unpack_frame = v210_planar_unpack_c;
60
61	if (HAVE_MMX)
62	ff_v210_x86_init(s);
63
64	return 0;
65	}
66
67	static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
68	AVPacket *avpkt)
69	{
70	V210DecContext *s = avctx->priv_data;
71
72	int h, w, ret, stride, aligned_input;
73	AVFrame *pic = data;
74	const uint8_t *psrc = avpkt->data;
75	uint16_t *y, *u, *v;
76
77	if (s->custom_stride )
78	stride = s->custom_stride;
79	else {
80	int aligned_width = ((avctx->width + 47) / 48) * 48;
81	stride = aligned_width * 8 / 3;
82	}
83
84	if (avpkt->size < stride * avctx->height) {
85	if ((((avctx->width + 23) / 24) * 24 * 8) / 3 * avctx->height == avpkt->size) {
86	stride = avpkt->size / avctx->height;
87	if (!s->stride_warning_shown)
88	av_log(avctx, AV_LOG_WARNING, "Broken v210 with too small padding (64 byte) detected\n");
89	s->stride_warning_shown = 1;
90	} else {
91	av_log(avctx, AV_LOG_ERROR, "packet too small\n");
92	return AVERROR_INVALIDDATA;
93	}
94	}
95
96	aligned_input = !((uintptr_t)psrc & 0xf) && !(stride & 0xf);
97	if (aligned_input != s->aligned_input) {
98	s->aligned_input = aligned_input;
99	if (HAVE_MMX)
100	ff_v210_x86_init(s);
101	}
102
103	if ((ret = ff_get_buffer(avctx, pic, 0)) < 0)
104	return ret;
105
106	y = (uint16_t*)pic->data[0];
107	u = (uint16_t*)pic->data[1];
108	v = (uint16_t*)pic->data[2];
109	pic->pict_type = AV_PICTURE_TYPE_I;
110	pic->key_frame = 1;
111
112	for (h = 0; h < avctx->height; h++) {
113	const uint32_t *src = (const uint32_t*)psrc;
114	uint32_t val;
115
116	w = (avctx->width / 6) * 6;
117	s->unpack_frame(src, y, u, v, w);
118
119	y += w;
120	u += w >> 1;
121	v += w >> 1;
122	src += (w << 1) / 3;
123
124	if (w < avctx->width - 1) {
125	READ_PIXELS(u, y, v);
126
127	val = av_le2ne32(*src++);
128	*y++ = val & 0x3FF;
129	if (w < avctx->width - 3) {
130	*u++ = (val >> 10) & 0x3FF;
131	*y++ = (val >> 20) & 0x3FF;
132
133	val = av_le2ne32(*src++);
134	*v++ = val & 0x3FF;
135	*y++ = (val >> 10) & 0x3FF;
136	}
137	}
138
139	psrc += stride;
140	y += pic->linesize[0] / 2 - avctx->width + (avctx->width & 1);
141	u += pic->linesize[1] / 2 - avctx->width / 2;
142	v += pic->linesize[2] / 2 - avctx->width / 2;
143	}
144
145	if (avctx->field_order > AV_FIELD_PROGRESSIVE) {
146	/* we have interlaced material flagged in container */
147	pic->interlaced_frame = 1;
148	if (avctx->field_order == AV_FIELD_TT || avctx->field_order == AV_FIELD_TB)
149	pic->top_field_first = 1;
150	}
151
152	*got_frame = 1;
153
154	return avpkt->size;
155	}
156
157	#define V210DEC_FLAGS AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_VIDEO_PARAM
158	static const AVOption v210dec_options[] = {
159	{"custom_stride", "Custom V210 stride", offsetof(V210DecContext, custom_stride), AV_OPT_TYPE_INT,
160	{.i64 = 0}, INT_MIN, INT_MAX, V210DEC_FLAGS},
161	{NULL}
162	};
163
164	static const AVClass v210dec_class = {
165	"V210 Decoder",
166	av_default_item_name,
167	v210dec_options,
168	LIBAVUTIL_VERSION_INT,
169	};
170
171	AVCodec ff_v210_decoder = {
172	.name = "v210",
173	.long_name = NULL_IF_CONFIG_SMALL("Uncompressed 4:2:2 10-bit"),
174	.type = AVMEDIA_TYPE_VIDEO,
175	.id = AV_CODEC_ID_V210,
176	.priv_data_size = sizeof(V210DecContext),
177	.init = decode_init,
178	.decode = decode_frame,
179	.capabilities = AV_CODEC_CAP_DR1,
180	.priv_class = &v210dec_class,
181	};
182