path: root/libavcodec/utvideoenc.c (plain)
blob: 840742caf713060788fa83eb632e5691a614e687

1	/*
2	* Ut Video encoder
3	* Copyright (c) 2012 Jan Ekström
4	*
5	* This file is part of FFmpeg.
6	*
7	* FFmpeg is free software; you can redistribute it and/or
8	* modify it under the terms of the GNU Lesser General Public
9	* License as published by the Free Software Foundation; either
10	* version 2.1 of the License, or (at your option) any later version.
11	*
12	* FFmpeg is distributed in the hope that it will be useful,
13	* but WITHOUT ANY WARRANTY; without even the implied warranty of
14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15	* Lesser General Public License for more details.
16	*
17	* You should have received a copy of the GNU Lesser General Public
18	* License along with FFmpeg; if not, write to the Free Software
19	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20	*/
21
22	/**
23	* @file
24	* Ut Video encoder
25	*/
26
27	#include "libavutil/imgutils.h"
28	#include "libavutil/intreadwrite.h"
29	#include "libavutil/opt.h"
30
31	#include "avcodec.h"
32	#include "internal.h"
33	#include "bswapdsp.h"
34	#include "bytestream.h"
35	#include "put_bits.h"
36	#include "mathops.h"
37	#include "utvideo.h"
38	#include "huffman.h"
39
40	/* Compare huffentry symbols */
41	static int huff_cmp_sym(const void *a, const void *b)
42	{
43	const HuffEntry *aa = a, *bb = b;
44	return aa->sym - bb->sym;
45	}
46
47	static av_cold int utvideo_encode_close(AVCodecContext *avctx)
48	{
49	UtvideoContext *c = avctx->priv_data;
50	int i;
51
52	av_freep(&c->slice_bits);
53	for (i = 0; i < 4; i++)
54	av_freep(&c->slice_buffer[i]);
55
56	return 0;
57	}
58
59	static av_cold int utvideo_encode_init(AVCodecContext *avctx)
60	{
61	UtvideoContext *c = avctx->priv_data;
62	int i, subsampled_height;
63	uint32_t original_format;
64
65	c->avctx = avctx;
66	c->frame_info_size = 4;
67	c->slice_stride = FFALIGN(avctx->width, 32);
68
69	switch (avctx->pix_fmt) {
70	case AV_PIX_FMT_RGB24:
71	c->planes = 3;
72	avctx->codec_tag = MKTAG('U', 'L', 'R', 'G');
73	original_format = UTVIDEO_RGB;
74	break;
75	case AV_PIX_FMT_RGBA:
76	c->planes = 4;
77	avctx->codec_tag = MKTAG('U', 'L', 'R', 'A');
78	original_format = UTVIDEO_RGBA;
79	avctx->bits_per_coded_sample = 32;
80	break;
81	case AV_PIX_FMT_YUV420P:
82	if (avctx->width & 1 || avctx->height & 1) {
83	av_log(avctx, AV_LOG_ERROR,
84	"4:2:0 video requires even width and height.\n");
85	return AVERROR_INVALIDDATA;
86	}
87	c->planes = 3;
88	if (avctx->colorspace == AVCOL_SPC_BT709)
89	avctx->codec_tag = MKTAG('U', 'L', 'H', '0');
90	else
91	avctx->codec_tag = MKTAG('U', 'L', 'Y', '0');
92	original_format = UTVIDEO_420;
93	break;
94	case AV_PIX_FMT_YUV422P:
95	if (avctx->width & 1) {
96	av_log(avctx, AV_LOG_ERROR,
97	"4:2:2 video requires even width.\n");
98	return AVERROR_INVALIDDATA;
99	}
100	c->planes = 3;
101	if (avctx->colorspace == AVCOL_SPC_BT709)
102	avctx->codec_tag = MKTAG('U', 'L', 'H', '2');
103	else
104	avctx->codec_tag = MKTAG('U', 'L', 'Y', '2');
105	original_format = UTVIDEO_422;
106	break;
107	case AV_PIX_FMT_YUV444P:
108	c->planes = 3;
109	if (avctx->colorspace == AVCOL_SPC_BT709)
110	avctx->codec_tag = MKTAG('U', 'L', 'H', '4');
111	else
112	avctx->codec_tag = MKTAG('U', 'L', 'Y', '4');
113	original_format = UTVIDEO_444;
114	break;
115	default:
116	av_log(avctx, AV_LOG_ERROR, "Unknown pixel format: %d\n",
117	avctx->pix_fmt);
118	return AVERROR_INVALIDDATA;
119	}
120
121	ff_bswapdsp_init(&c->bdsp);
122	ff_llvidencdsp_init(&c->llvidencdsp);
123
124	#if FF_API_PRIVATE_OPT
125	FF_DISABLE_DEPRECATION_WARNINGS
126	/* Check the prediction method, and error out if unsupported */
127	if (avctx->prediction_method < 0 || avctx->prediction_method > 4) {
128	av_log(avctx, AV_LOG_WARNING,
129	"Prediction method %d is not supported in Ut Video.\n",
130	avctx->prediction_method);
131	return AVERROR_OPTION_NOT_FOUND;
132	}
133
134	if (avctx->prediction_method == FF_PRED_PLANE) {
135	av_log(avctx, AV_LOG_ERROR,
136	"Plane prediction is not supported in Ut Video.\n");
137	return AVERROR_OPTION_NOT_FOUND;
138	}
139
140	/* Convert from libavcodec prediction type to Ut Video's */
141	if (avctx->prediction_method)
142	c->frame_pred = ff_ut_pred_order[avctx->prediction_method];
143	FF_ENABLE_DEPRECATION_WARNINGS
144	#endif
145
146	if (c->frame_pred == PRED_GRADIENT) {
147	av_log(avctx, AV_LOG_ERROR, "Gradient prediction is not supported.\n");
148	return AVERROR_OPTION_NOT_FOUND;
149	}
150
151	/*
152	* Check the asked slice count for obviously invalid
153	* values (> 256 or negative).
154	*/
155	if (avctx->slices > 256 || avctx->slices < 0) {
156	av_log(avctx, AV_LOG_ERROR,
157	"Slice count %d is not supported in Ut Video (theoretical range is 0-256).\n",
158	avctx->slices);
159	return AVERROR(EINVAL);
160	}
161
162	/* Check that the slice count is not larger than the subsampled height */
163	subsampled_height = avctx->height >> av_pix_fmt_desc_get(avctx->pix_fmt)->log2_chroma_h;
164	if (avctx->slices > subsampled_height) {
165	av_log(avctx, AV_LOG_ERROR,
166	"Slice count %d is larger than the subsampling-applied height %d.\n",
167	avctx->slices, subsampled_height);
168	return AVERROR(EINVAL);
169	}
170
171	/* extradata size is 4 * 32 bits */
172	avctx->extradata_size = 16;
173
174	avctx->extradata = av_mallocz(avctx->extradata_size +
175	AV_INPUT_BUFFER_PADDING_SIZE);
176
177	if (!avctx->extradata) {
178	av_log(avctx, AV_LOG_ERROR, "Could not allocate extradata.\n");
179	utvideo_encode_close(avctx);
180	return AVERROR(ENOMEM);
181	}
182
183	for (i = 0; i < c->planes; i++) {
184	c->slice_buffer[i] = av_malloc(c->slice_stride * (avctx->height + 2) +
185	AV_INPUT_BUFFER_PADDING_SIZE);
186	if (!c->slice_buffer[i]) {
187	av_log(avctx, AV_LOG_ERROR, "Cannot allocate temporary buffer 1.\n");
188	utvideo_encode_close(avctx);
189	return AVERROR(ENOMEM);
190	}
191	}
192
193	/*
194	* Set the version of the encoder.
195	* Last byte is "implementation ID", which is
196	* obtained from the creator of the format.
197	* Libavcodec has been assigned with the ID 0xF0.
198	*/
199	AV_WB32(avctx->extradata, MKTAG(1, 0, 0, 0xF0));
200
201	/*
202	* Set the "original format"
203	* Not used for anything during decoding.
204	*/
205	AV_WL32(avctx->extradata + 4, original_format);
206
207	/* Write 4 as the 'frame info size' */
208	AV_WL32(avctx->extradata + 8, c->frame_info_size);
209
210	/*
211	* Set how many slices are going to be used.
212	* By default uses multiple slices depending on the subsampled height.
213	* This enables multithreading in the official decoder.
214	*/
215	if (!avctx->slices) {
216	c->slices = subsampled_height / 120;
217
218	if (!c->slices)
219	c->slices = 1;
220	else if (c->slices > 256)
221	c->slices = 256;
222	} else {
223	c->slices = avctx->slices;
224	}
225
226	/* Set compression mode */
227	c->compression = COMP_HUFF;
228
229	/*
230	* Set the encoding flags:
231	* - Slice count minus 1
232	* - Interlaced encoding mode flag, set to zero for now.
233	* - Compression mode (none/huff)
234	* And write the flags.
235	*/
236	c->flags = (c->slices - 1) << 24;
237	c->flags |= 0 << 11; // bit field to signal interlaced encoding mode
238	c->flags |= c->compression;
239
240	AV_WL32(avctx->extradata + 12, c->flags);
241
242	return 0;
243	}
244
245	static void mangle_rgb_planes(uint8_t *dst[4], ptrdiff_t dst_stride,
246	uint8_t *src, int step, ptrdiff_t stride,
247	int width, int height)
248	{
249	int i, j;
250	int k = 2 * dst_stride;
251	unsigned int g;
252
253	for (j = 0; j < height; j++) {
254	if (step == 3) {
255	for (i = 0; i < width * step; i += step) {
256	g = src[i + 1];
257	dst[0][k] = g;
258	g += 0x80;
259	dst[1][k] = src[i + 2] - g;
260	dst[2][k] = src[i + 0] - g;
261	k++;
262	}
263	} else {
264	for (i = 0; i < width * step; i += step) {
265	g = src[i + 1];
266	dst[0][k] = g;
267	g += 0x80;
268	dst[1][k] = src[i + 2] - g;
269	dst[2][k] = src[i + 0] - g;
270	dst[3][k] = src[i + 3];
271	k++;
272	}
273	}
274	k += dst_stride - width;
275	src += stride;
276	}
277	}
278
279	/* Write data to a plane with left prediction */
280	static void left_predict(uint8_t *src, uint8_t *dst, ptrdiff_t stride,
281	int width, int height)
282	{
283	int i, j;
284	uint8_t prev;
285
286	prev = 0x80; /* Set the initial value */
287	for (j = 0; j < height; j++) {
288	for (i = 0; i < width; i++) {
289	*dst++ = src[i] - prev;
290	prev = src[i];
291	}
292	src += stride;
293	}
294	}
295
296	#undef A
297	#undef B
298
299	/* Write data to a plane with median prediction */
300	static void median_predict(UtvideoContext *c, uint8_t *src, uint8_t *dst,
301	ptrdiff_t stride, int width, int height)
302	{
303	int i, j;
304	int A, B;
305	uint8_t prev;
306
307	/* First line uses left neighbour prediction */
308	prev = 0x80; /* Set the initial value */
309	for (i = 0; i < width; i++) {
310	*dst++ = src[i] - prev;
311	prev = src[i];
312	}
313
314	if (height == 1)
315	return;
316
317	src += stride;
318
319	/*
320	* Second line uses top prediction for the first sample,
321	* and median for the rest.
322	*/
323	A = B = 0;
324
325	/* Rest of the coded part uses median prediction */
326	for (j = 1; j < height; j++) {
327	c->llvidencdsp.sub_median_pred(dst, src - stride, src, width, &A, &B);
328	dst += width;
329	src += stride;
330	}
331	}
332
333	/* Count the usage of values in a plane */
334	static void count_usage(uint8_t *src, int width,
335	int height, uint64_t *counts)
336	{
337	int i, j;
338
339	for (j = 0; j < height; j++) {
340	for (i = 0; i < width; i++) {
341	counts[src[i]]++;
342	}
343	src += width;
344	}
345	}
346
347	/* Calculate the actual huffman codes from the code lengths */
348	static void calculate_codes(HuffEntry *he)
349	{
350	int last, i;
351	uint32_t code;
352
353	qsort(he, 256, sizeof(*he), ff_ut_huff_cmp_len);
354
355	last = 255;
356	while (he[last].len == 255 && last)
357	last--;
358
359	code = 1;
360	for (i = last; i >= 0; i--) {
361	he[i].code = code >> (32 - he[i].len);
362	code += 0x80000000u >> (he[i].len - 1);
363	}
364
365	qsort(he, 256, sizeof(*he), huff_cmp_sym);
366	}
367
368	/* Write huffman bit codes to a memory block */
369	static int write_huff_codes(uint8_t *src, uint8_t *dst, int dst_size,
370	int width, int height, HuffEntry *he)
371	{
372	PutBitContext pb;
373	int i, j;
374	int count;
375
376	init_put_bits(&pb, dst, dst_size);
377
378	/* Write the codes */
379	for (j = 0; j < height; j++) {
380	for (i = 0; i < width; i++)
381	put_bits(&pb, he[src[i]].len, he[src[i]].code);
382
383	src += width;
384	}
385
386	/* Pad output to a 32-bit boundary */
387	count = put_bits_count(&pb) & 0x1F;
388
389	if (count)
390	put_bits(&pb, 32 - count, 0);
391
392	/* Get the amount of bits written */
393	count = put_bits_count(&pb);
394
395	/* Flush the rest with zeroes */
396	flush_put_bits(&pb);
397
398	return count;
399	}
400
401	static int encode_plane(AVCodecContext *avctx, uint8_t *src,
402	uint8_t *dst, ptrdiff_t stride, int plane_no,
403	int width, int height, PutByteContext *pb)
404	{
405	UtvideoContext *c = avctx->priv_data;
406	uint8_t lengths[256];
407	uint64_t counts[256] = { 0 };
408
409	HuffEntry he[256];
410
411	uint32_t offset = 0, slice_len = 0;
412	const int cmask = ~(!plane_no && avctx->pix_fmt == AV_PIX_FMT_YUV420P);
413	int i, sstart, send = 0;
414	int symbol;
415	int ret;
416
417	/* Do prediction / make planes */
418	switch (c->frame_pred) {
419	case PRED_NONE:
420	for (i = 0; i < c->slices; i++) {
421	sstart = send;
422	send = height * (i + 1) / c->slices & cmask;
423	av_image_copy_plane(dst + sstart * width, width,
424	src + sstart * stride, stride,
425	width, send - sstart);
426	}
427	break;
428	case PRED_LEFT:
429	for (i = 0; i < c->slices; i++) {
430	sstart = send;
431	send = height * (i + 1) / c->slices & cmask;
432	left_predict(src + sstart * stride, dst + sstart * width,
433	stride, width, send - sstart);
434	}
435	break;
436	case PRED_MEDIAN:
437	for (i = 0; i < c->slices; i++) {
438	sstart = send;
439	send = height * (i + 1) / c->slices & cmask;
440	median_predict(c, src + sstart * stride, dst + sstart * width,
441	stride, width, send - sstart);
442	}
443	break;
444	default:
445	av_log(avctx, AV_LOG_ERROR, "Unknown prediction mode: %d\n",
446	c->frame_pred);
447	return AVERROR_OPTION_NOT_FOUND;
448	}
449
450	/* Count the usage of values */
451	count_usage(dst, width, height, counts);
452
453	/* Check for a special case where only one symbol was used */
454	for (symbol = 0; symbol < 256; symbol++) {
455	/* If non-zero count is found, see if it matches width * height */
456	if (counts[symbol]) {
457	/* Special case if only one symbol was used */
458	if (counts[symbol] == width * (int64_t)height) {
459	/*
460	* Write a zero for the single symbol
461	* used in the plane, else 0xFF.
462	*/
463	for (i = 0; i < 256; i++) {
464	if (i == symbol)
465	bytestream2_put_byte(pb, 0);
466	else
467	bytestream2_put_byte(pb, 0xFF);
468	}
469
470	/* Write zeroes for lengths */
471	for (i = 0; i < c->slices; i++)
472	bytestream2_put_le32(pb, 0);
473
474	/* And that's all for that plane folks */
475	return 0;
476	}
477	break;
478	}
479	}
480
481	/* Calculate huffman lengths */
482	if ((ret = ff_huff_gen_len_table(lengths, counts, 256, 1)) < 0)
483	return ret;
484
485	/*
486	* Write the plane's header into the output packet:
487	* - huffman code lengths (256 bytes)
488	* - slice end offsets (gotten from the slice lengths)
489	*/
490	for (i = 0; i < 256; i++) {
491	bytestream2_put_byte(pb, lengths[i]);
492
493	he[i].len = lengths[i];
494	he[i].sym = i;
495	}
496
497	/* Calculate the huffman codes themselves */
498	calculate_codes(he);
499
500	send = 0;
501	for (i = 0; i < c->slices; i++) {
502	sstart = send;
503	send = height * (i + 1) / c->slices & cmask;
504
505	/*
506	* Write the huffman codes to a buffer,
507	* get the offset in bits and convert to bytes.
508	*/
509	offset += write_huff_codes(dst + sstart * width, c->slice_bits,
510	width * height + 4, width,
511	send - sstart, he) >> 3;
512
513	slice_len = offset - slice_len;
514
515	/* Byteswap the written huffman codes */
516	c->bdsp.bswap_buf((uint32_t *) c->slice_bits,
517	(uint32_t *) c->slice_bits,
518	slice_len >> 2);
519
520	/* Write the offset to the stream */
521	bytestream2_put_le32(pb, offset);
522
523	/* Seek to the data part of the packet */
524	bytestream2_seek_p(pb, 4 * (c->slices - i - 1) +
525	offset - slice_len, SEEK_CUR);
526
527	/* Write the slices' data into the output packet */
528	bytestream2_put_buffer(pb, c->slice_bits, slice_len);
529
530	/* Seek back to the slice offsets */
531	bytestream2_seek_p(pb, -4 * (c->slices - i - 1) - offset,
532	SEEK_CUR);
533
534	slice_len = offset;
535	}
536
537	/* And at the end seek to the end of written slice(s) */
538	bytestream2_seek_p(pb, offset, SEEK_CUR);
539
540	return 0;
541	}
542
543	static int utvideo_encode_frame(AVCodecContext *avctx, AVPacket *pkt,
544	const AVFrame *pic, int *got_packet)
545	{
546	UtvideoContext *c = avctx->priv_data;
547	PutByteContext pb;
548
549	uint32_t frame_info;
550
551	uint8_t *dst;
552
553	int width = avctx->width, height = avctx->height;
554	int i, ret = 0;
555
556	/* Allocate a new packet if needed, and set it to the pointer dst */
557	ret = ff_alloc_packet2(avctx, pkt, (256 + 4 * c->slices + width * height) *
558	c->planes + 4, 0);
559
560	if (ret < 0)
561	return ret;
562
563	dst = pkt->data;
564
565	bytestream2_init_writer(&pb, dst, pkt->size);
566
567	av_fast_padded_malloc(&c->slice_bits, &c->slice_bits_size, width * height + 4);
568
569	if (!c->slice_bits) {
570	av_log(avctx, AV_LOG_ERROR, "Cannot allocate temporary buffer 2.\n");
571	return AVERROR(ENOMEM);
572	}
573
574	/* In case of RGB, mangle the planes to Ut Video's format */
575	if (avctx->pix_fmt == AV_PIX_FMT_RGBA || avctx->pix_fmt == AV_PIX_FMT_RGB24)
576	mangle_rgb_planes(c->slice_buffer, c->slice_stride, pic->data[0],
577	c->planes, pic->linesize[0], width, height);
578
579	/* Deal with the planes */
580	switch (avctx->pix_fmt) {
581	case AV_PIX_FMT_RGB24:
582	case AV_PIX_FMT_RGBA:
583	for (i = 0; i < c->planes; i++) {
584	ret = encode_plane(avctx, c->slice_buffer[i] + 2 * c->slice_stride,
585	c->slice_buffer[i], c->slice_stride, i,
586	width, height, &pb);
587
588	if (ret) {
589	av_log(avctx, AV_LOG_ERROR, "Error encoding plane %d.\n", i);
590	return ret;
591	}
592	}
593	break;
594	case AV_PIX_FMT_YUV444P:
595	for (i = 0; i < c->planes; i++) {
596	ret = encode_plane(avctx, pic->data[i], c->slice_buffer[0],
597	pic->linesize[i], i, width, height, &pb);
598
599	if (ret) {
600	av_log(avctx, AV_LOG_ERROR, "Error encoding plane %d.\n", i);
601	return ret;
602	}
603	}
604	break;
605	case AV_PIX_FMT_YUV422P:
606	for (i = 0; i < c->planes; i++) {
607	ret = encode_plane(avctx, pic->data[i], c->slice_buffer[0],
608	pic->linesize[i], i, width >> !!i, height, &pb);
609
610	if (ret) {
611	av_log(avctx, AV_LOG_ERROR, "Error encoding plane %d.\n", i);
612	return ret;
613	}
614	}
615	break;
616	case AV_PIX_FMT_YUV420P:
617	for (i = 0; i < c->planes; i++) {
618	ret = encode_plane(avctx, pic->data[i], c->slice_buffer[0],
619	pic->linesize[i], i, width >> !!i, height >> !!i,
620	&pb);
621
622	if (ret) {
623	av_log(avctx, AV_LOG_ERROR, "Error encoding plane %d.\n", i);
624	return ret;
625	}
626	}
627	break;
628	default:
629	av_log(avctx, AV_LOG_ERROR, "Unknown pixel format: %d\n",
630	avctx->pix_fmt);
631	return AVERROR_INVALIDDATA;
632	}
633
634	/*
635	* Write frame information (LE 32-bit unsigned)
636	* into the output packet.
637	* Contains the prediction method.
638	*/
639	frame_info = c->frame_pred << 8;
640	bytestream2_put_le32(&pb, frame_info);
641
642	/*
643	* At least currently Ut Video is IDR only.
644	* Set flags accordingly.
645	*/
646	#if FF_API_CODED_FRAME
647	FF_DISABLE_DEPRECATION_WARNINGS
648	avctx->coded_frame->key_frame = 1;
649	avctx->coded_frame->pict_type = AV_PICTURE_TYPE_I;
650	FF_ENABLE_DEPRECATION_WARNINGS
651	#endif
652
653	pkt->size = bytestream2_tell_p(&pb);
654	pkt->flags |= AV_PKT_FLAG_KEY;
655
656	/* Packet should be done */
657	*got_packet = 1;
658
659	return 0;
660	}
661
662	#define OFFSET(x) offsetof(UtvideoContext, x)
663	#define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
664	static const AVOption options[] = {
665	{ "pred", "Prediction method", OFFSET(frame_pred), AV_OPT_TYPE_INT, { .i64 = PRED_LEFT }, PRED_NONE, PRED_MEDIAN, VE, "pred" },
666	{ "none", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = PRED_NONE }, INT_MIN, INT_MAX, VE, "pred" },
667	{ "left", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = PRED_LEFT }, INT_MIN, INT_MAX, VE, "pred" },
668	{ "gradient", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = PRED_GRADIENT }, INT_MIN, INT_MAX, VE, "pred" },
669	{ "median", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = PRED_MEDIAN }, INT_MIN, INT_MAX, VE, "pred" },
670
671	{ NULL},
672	};
673
674	static const AVClass utvideo_class = {
675	.class_name = "utvideo",
676	.item_name = av_default_item_name,
677	.option = options,
678	.version = LIBAVUTIL_VERSION_INT,
679	};
680
681	AVCodec ff_utvideo_encoder = {
682	.name = "utvideo",
683	.long_name = NULL_IF_CONFIG_SMALL("Ut Video"),
684	.type = AVMEDIA_TYPE_VIDEO,
685	.id = AV_CODEC_ID_UTVIDEO,
686	.priv_data_size = sizeof(UtvideoContext),
687	.priv_class = &utvideo_class,
688	.init = utvideo_encode_init,
689	.encode2 = utvideo_encode_frame,
690	.close = utvideo_encode_close,
691	.capabilities = AV_CODEC_CAP_FRAME_THREADS | AV_CODEC_CAP_INTRA_ONLY,
692	.pix_fmts = (const enum AVPixelFormat[]) {
693	AV_PIX_FMT_RGB24, AV_PIX_FMT_RGBA, AV_PIX_FMT_YUV422P,
694	AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV444P, AV_PIX_FMT_NONE
695	},
696	};
697