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