Line | Branch | Exec | Source |
---|---|---|---|
1 | /* | ||
2 | * Copyright (c) 2002-2014 Michael Niedermayer <michaelni@gmx.at> | ||
3 | * | ||
4 | * see https://multimedia.cx/huffyuv.txt for a description of | ||
5 | * the algorithm used | ||
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 | * yuva, gray, 4:4:4, 4:1:1, 4:1:0 and >8 bit per sample support sponsored by NOA | ||
24 | */ | ||
25 | |||
26 | /** | ||
27 | * @file | ||
28 | * huffyuv encoder | ||
29 | */ | ||
30 | |||
31 | #include "config_components.h" | ||
32 | |||
33 | #include "avcodec.h" | ||
34 | #include "bswapdsp.h" | ||
35 | #include "codec_internal.h" | ||
36 | #include "encode.h" | ||
37 | #include "huffyuv.h" | ||
38 | #include "huffman.h" | ||
39 | #include "huffyuvencdsp.h" | ||
40 | #include "lossless_videoencdsp.h" | ||
41 | #include "put_bits.h" | ||
42 | #include "libavutil/opt.h" | ||
43 | #include "libavutil/pixdesc.h" | ||
44 | |||
45 | typedef struct HYuvEncContext { | ||
46 | AVClass *class; | ||
47 | AVCodecContext *avctx; | ||
48 | PutBitContext pb; | ||
49 | Predictor predictor; | ||
50 | int interlaced; | ||
51 | int decorrelate; | ||
52 | int bitstream_bpp; | ||
53 | int version; | ||
54 | int bps; | ||
55 | int n; // 1<<bps | ||
56 | int vlc_n; // number of vlc codes (FFMIN(1<<bps, MAX_VLC_N)) | ||
57 | int alpha; | ||
58 | int chroma; | ||
59 | int yuv; | ||
60 | int chroma_h_shift; | ||
61 | int chroma_v_shift; | ||
62 | int flags; | ||
63 | int context; | ||
64 | int picture_number; | ||
65 | |||
66 | uint8_t *temp[3]; | ||
67 | uint16_t *temp16[3]; ///< identical to temp but 16bit type | ||
68 | uint64_t stats[4][MAX_VLC_N]; | ||
69 | uint8_t len[4][MAX_VLC_N]; | ||
70 | uint32_t bits[4][MAX_VLC_N]; | ||
71 | BswapDSPContext bdsp; | ||
72 | HuffYUVEncDSPContext hencdsp; | ||
73 | LLVidEncDSPContext llvidencdsp; | ||
74 | int non_determ; // non-deterministic, multi-threaded encoder allowed | ||
75 | } HYuvEncContext; | ||
76 | |||
77 | 134100 | static inline void diff_bytes(HYuvEncContext *s, uint8_t *dst, | |
78 | const uint8_t *src0, const uint8_t *src1, int w) | ||
79 | { | ||
80 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 134100 times.
|
134100 | if (s->bps <= 8) { |
81 | ✗ | s->llvidencdsp.diff_bytes(dst, src0, src1, w); | |
82 | } else { | ||
83 | 134100 | s->hencdsp.diff_int16((uint16_t *)dst, (const uint16_t *)src0, (const uint16_t *)src1, s->n - 1, w); | |
84 | } | ||
85 | 134100 | } | |
86 | |||
87 | 718400 | static inline int sub_left_prediction(HYuvEncContext *s, uint8_t *dst, | |
88 | const uint8_t *src, int w, int left) | ||
89 | { | ||
90 | int i; | ||
91 | 718400 | int min_width = FFMIN(w, 32); | |
92 | |||
93 |
2/2✓ Branch 0 taken 359200 times.
✓ Branch 1 taken 359200 times.
|
718400 | if (s->bps <= 8) { |
94 |
2/2✓ Branch 0 taken 11417900 times.
✓ Branch 1 taken 359200 times.
|
11777100 | for (i = 0; i < min_width; i++) { /* scalar loop before dsp call */ |
95 | 11417900 | const int temp = src[i]; | |
96 | 11417900 | dst[i] = temp - left; | |
97 | 11417900 | left = temp; | |
98 | } | ||
99 |
2/2✓ Branch 0 taken 5100 times.
✓ Branch 1 taken 354100 times.
|
359200 | if (w < 32) |
100 | 5100 | return left; | |
101 | 354100 | s->llvidencdsp.diff_bytes(dst + 32, src + 32, src + 31, w - 32); | |
102 | 354100 | return src[w-1]; | |
103 | } else { | ||
104 | 359200 | const uint16_t *src16 = (const uint16_t *)src; | |
105 | 359200 | uint16_t *dst16 = ( uint16_t *)dst; | |
106 |
2/2✓ Branch 0 taken 11417900 times.
✓ Branch 1 taken 359200 times.
|
11777100 | for (i = 0; i < min_width; i++) { /* scalar loop before dsp call */ |
107 | 11417900 | const int temp = src16[i]; | |
108 | 11417900 | dst16[i] = temp - left; | |
109 | 11417900 | left = temp; | |
110 | } | ||
111 |
2/2✓ Branch 0 taken 5100 times.
✓ Branch 1 taken 354100 times.
|
359200 | if (w < 32) |
112 | 5100 | return left; | |
113 | 354100 | s->hencdsp.diff_int16(dst16 + 32, src16 + 32, src16 + 31, s->n - 1, w - 32); | |
114 | 354100 | return src16[w-1]; | |
115 | } | ||
116 | } | ||
117 | |||
118 | 44900 | static inline void sub_left_prediction_bgr32(HYuvEncContext *s, uint8_t *dst, | |
119 | const uint8_t *src, int w, | ||
120 | int *red, int *green, int *blue, | ||
121 | int *alpha) | ||
122 | { | ||
123 | int i; | ||
124 | int r, g, b, a; | ||
125 | 44900 | int min_width = FFMIN(w, 8); | |
126 | 44900 | r = *red; | |
127 | 44900 | g = *green; | |
128 | 44900 | b = *blue; | |
129 | 44900 | a = *alpha; | |
130 | |||
131 |
2/2✓ Branch 0 taken 359200 times.
✓ Branch 1 taken 44900 times.
|
404100 | for (i = 0; i < min_width; i++) { |
132 | 359200 | const int rt = src[i * 4 + R]; | |
133 | 359200 | const int gt = src[i * 4 + G]; | |
134 | 359200 | const int bt = src[i * 4 + B]; | |
135 | 359200 | const int at = src[i * 4 + A]; | |
136 | 359200 | dst[i * 4 + R] = rt - r; | |
137 | 359200 | dst[i * 4 + G] = gt - g; | |
138 | 359200 | dst[i * 4 + B] = bt - b; | |
139 | 359200 | dst[i * 4 + A] = at - a; | |
140 | 359200 | r = rt; | |
141 | 359200 | g = gt; | |
142 | 359200 | b = bt; | |
143 | 359200 | a = at; | |
144 | } | ||
145 | |||
146 | 44900 | s->llvidencdsp.diff_bytes(dst + 32, src + 32, src + 32 - 4, w * 4 - 32); | |
147 | |||
148 | 44900 | *red = src[(w - 1) * 4 + R]; | |
149 | 44900 | *green = src[(w - 1) * 4 + G]; | |
150 | 44900 | *blue = src[(w - 1) * 4 + B]; | |
151 | 44900 | *alpha = src[(w - 1) * 4 + A]; | |
152 | 44900 | } | |
153 | |||
154 | 44900 | static inline void sub_left_prediction_rgb24(HYuvEncContext *s, uint8_t *dst, | |
155 | const uint8_t *src, int w, | ||
156 | int *red, int *green, int *blue) | ||
157 | { | ||
158 | int i; | ||
159 | int r, g, b; | ||
160 | 44900 | r = *red; | |
161 | 44900 | g = *green; | |
162 | 44900 | b = *blue; | |
163 |
2/2✓ Branch 0 taken 718400 times.
✓ Branch 1 taken 44900 times.
|
763300 | for (i = 0; i < FFMIN(w, 16); i++) { |
164 | 718400 | const int rt = src[i * 3 + 0]; | |
165 | 718400 | const int gt = src[i * 3 + 1]; | |
166 | 718400 | const int bt = src[i * 3 + 2]; | |
167 | 718400 | dst[i * 3 + 0] = rt - r; | |
168 | 718400 | dst[i * 3 + 1] = gt - g; | |
169 | 718400 | dst[i * 3 + 2] = bt - b; | |
170 | 718400 | r = rt; | |
171 | 718400 | g = gt; | |
172 | 718400 | b = bt; | |
173 | } | ||
174 | |||
175 | 44900 | s->llvidencdsp.diff_bytes(dst + 48, src + 48, src + 48 - 3, w * 3 - 48); | |
176 | |||
177 | 44900 | *red = src[(w - 1) * 3 + 0]; | |
178 | 44900 | *green = src[(w - 1) * 3 + 1]; | |
179 | 44900 | *blue = src[(w - 1) * 3 + 2]; | |
180 | 44900 | } | |
181 | |||
182 | ✗ | static void sub_median_prediction(HYuvEncContext *s, uint8_t *dst, | |
183 | const uint8_t *src1, const uint8_t *src2, | ||
184 | int w, int *left, int *left_top) | ||
185 | { | ||
186 | ✗ | if (s->bps <= 8) { | |
187 | ✗ | s->llvidencdsp.sub_median_pred(dst, src1, src2, w , left, left_top); | |
188 | } else { | ||
189 | ✗ | s->hencdsp.sub_hfyu_median_pred_int16((uint16_t *)dst, (const uint16_t *)src1, (const uint16_t *)src2, s->n - 1, w , left, left_top); | |
190 | } | ||
191 | } | ||
192 | |||
193 | 96 | static int store_table(HYuvEncContext *s, const uint8_t *len, uint8_t *buf) | |
194 | { | ||
195 | int i; | ||
196 | 96 | int index = 0; | |
197 | 96 | int n = s->vlc_n; | |
198 | |||
199 |
2/2✓ Branch 0 taken 3876 times.
✓ Branch 1 taken 96 times.
|
3972 | for (i = 0; i < n;) { |
200 | 3876 | int val = len[i]; | |
201 | 3876 | int repeat = 0; | |
202 | |||
203 |
6/6✓ Branch 0 taken 277188 times.
✓ Branch 1 taken 96 times.
✓ Branch 2 taken 274140 times.
✓ Branch 3 taken 3048 times.
✓ Branch 4 taken 273408 times.
✓ Branch 5 taken 732 times.
|
277284 | for (; i < n && len[i] == val && repeat < 255; i++) |
204 | 273408 | repeat++; | |
205 | |||
206 |
4/8✓ Branch 0 taken 3876 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 3876 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 3876 times.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✓ Branch 7 taken 3876 times.
|
3876 | av_assert0(val < 32 && val >0 && repeat < 256 && repeat>0); |
207 |
2/2✓ Branch 0 taken 2244 times.
✓ Branch 1 taken 1632 times.
|
3876 | if (repeat > 7) { |
208 | 2244 | buf[index++] = val; | |
209 | 2244 | buf[index++] = repeat; | |
210 | } else { | ||
211 | 1632 | buf[index++] = val | (repeat << 5); | |
212 | } | ||
213 | } | ||
214 | |||
215 | 96 | return index; | |
216 | } | ||
217 | |||
218 | 32 | static int store_huffman_tables(HYuvEncContext *s, uint8_t *buf) | |
219 | { | ||
220 | int i, ret; | ||
221 | 32 | int size = 0; | |
222 | 32 | int count = 3; | |
223 | |||
224 |
2/2✓ Branch 0 taken 16 times.
✓ Branch 1 taken 16 times.
|
32 | if (s->version > 2) |
225 | 16 | count = 1 + s->alpha + 2*s->chroma; | |
226 | |||
227 |
2/2✓ Branch 0 taken 96 times.
✓ Branch 1 taken 32 times.
|
128 | for (i = 0; i < count; i++) { |
228 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 96 times.
|
96 | if ((ret = ff_huff_gen_len_table(s->len[i], s->stats[i], s->vlc_n, 0)) < 0) |
229 | ✗ | return ret; | |
230 | |||
231 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 96 times.
|
96 | if (ff_huffyuv_generate_bits_table(s->bits[i], s->len[i], s->vlc_n) < 0) { |
232 | ✗ | return -1; | |
233 | } | ||
234 | |||
235 | 96 | size += store_table(s, s->len[i], buf + size); | |
236 | } | ||
237 | 32 | return size; | |
238 | } | ||
239 | |||
240 | 32 | static av_cold int encode_init(AVCodecContext *avctx) | |
241 | { | ||
242 | 32 | HYuvEncContext *s = avctx->priv_data; | |
243 | int i, j; | ||
244 | int ret; | ||
245 | const AVPixFmtDescriptor *desc; | ||
246 | |||
247 | 32 | s->avctx = avctx; | |
248 | 32 | s->flags = avctx->flags; | |
249 | |||
250 | 32 | ff_bswapdsp_init(&s->bdsp); | |
251 | 32 | ff_huffyuvencdsp_init(&s->hencdsp, avctx->pix_fmt); | |
252 | 32 | ff_llvidencdsp_init(&s->llvidencdsp); | |
253 | |||
254 | 32 | avctx->extradata = av_mallocz(3*MAX_N + 4); | |
255 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 32 times.
|
32 | if (!avctx->extradata) |
256 | ✗ | return AVERROR(ENOMEM); | |
257 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 32 times.
|
32 | if (s->flags&AV_CODEC_FLAG_PASS1) { |
258 | #define STATS_OUT_SIZE 21*MAX_N*3 + 4 | ||
259 | ✗ | avctx->stats_out = av_mallocz(STATS_OUT_SIZE); // 21*256*3(%llu ) + 3(\n) + 1(0) = 16132 | |
260 | ✗ | if (!avctx->stats_out) | |
261 | ✗ | return AVERROR(ENOMEM); | |
262 | } | ||
263 | 32 | s->version = 2; | |
264 | |||
265 | 32 | desc = av_pix_fmt_desc_get(avctx->pix_fmt); | |
266 | 32 | s->bps = desc->comp[0].depth; | |
267 |
3/4✓ Branch 0 taken 24 times.
✓ Branch 1 taken 8 times.
✓ Branch 2 taken 24 times.
✗ Branch 3 not taken.
|
32 | s->yuv = !(desc->flags & AV_PIX_FMT_FLAG_RGB) && desc->nb_components >= 2; |
268 | 32 | s->chroma = desc->nb_components > 2; | |
269 | 32 | s->alpha = !!(desc->flags & AV_PIX_FMT_FLAG_ALPHA); | |
270 | 32 | s->chroma_h_shift = desc->log2_chroma_w; | |
271 | 32 | s->chroma_v_shift = desc->log2_chroma_h; | |
272 | |||
273 |
4/5✓ Branch 0 taken 8 times.
✓ Branch 1 taken 16 times.
✓ Branch 2 taken 4 times.
✓ Branch 3 taken 4 times.
✗ Branch 4 not taken.
|
32 | switch (avctx->pix_fmt) { |
274 | 8 | case AV_PIX_FMT_YUV420P: | |
275 | case AV_PIX_FMT_YUV422P: | ||
276 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 8 times.
|
8 | if (avctx->width & 1) { |
277 | ✗ | av_log(avctx, AV_LOG_ERROR, "Width must be even for this colorspace.\n"); | |
278 | ✗ | return AVERROR(EINVAL); | |
279 | } | ||
280 |
2/2✓ Branch 0 taken 4 times.
✓ Branch 1 taken 4 times.
|
8 | s->bitstream_bpp = avctx->pix_fmt == AV_PIX_FMT_YUV420P ? 12 : 16; |
281 | 8 | break; | |
282 | 16 | case AV_PIX_FMT_YUV444P: | |
283 | case AV_PIX_FMT_YUV410P: | ||
284 | case AV_PIX_FMT_YUV411P: | ||
285 | case AV_PIX_FMT_YUV440P: | ||
286 | case AV_PIX_FMT_GBRP: | ||
287 | case AV_PIX_FMT_GBRP9: | ||
288 | case AV_PIX_FMT_GBRP10: | ||
289 | case AV_PIX_FMT_GBRP12: | ||
290 | case AV_PIX_FMT_GBRP14: | ||
291 | case AV_PIX_FMT_GBRP16: | ||
292 | case AV_PIX_FMT_GRAY8: | ||
293 | case AV_PIX_FMT_GRAY16: | ||
294 | case AV_PIX_FMT_YUVA444P: | ||
295 | case AV_PIX_FMT_YUVA420P: | ||
296 | case AV_PIX_FMT_YUVA422P: | ||
297 | case AV_PIX_FMT_GBRAP: | ||
298 | case AV_PIX_FMT_YUV420P9: | ||
299 | case AV_PIX_FMT_YUV420P10: | ||
300 | case AV_PIX_FMT_YUV420P12: | ||
301 | case AV_PIX_FMT_YUV420P14: | ||
302 | case AV_PIX_FMT_YUV420P16: | ||
303 | case AV_PIX_FMT_YUV422P9: | ||
304 | case AV_PIX_FMT_YUV422P10: | ||
305 | case AV_PIX_FMT_YUV422P12: | ||
306 | case AV_PIX_FMT_YUV422P14: | ||
307 | case AV_PIX_FMT_YUV422P16: | ||
308 | case AV_PIX_FMT_YUV444P9: | ||
309 | case AV_PIX_FMT_YUV444P10: | ||
310 | case AV_PIX_FMT_YUV444P12: | ||
311 | case AV_PIX_FMT_YUV444P14: | ||
312 | case AV_PIX_FMT_YUV444P16: | ||
313 | case AV_PIX_FMT_YUVA420P9: | ||
314 | case AV_PIX_FMT_YUVA420P10: | ||
315 | case AV_PIX_FMT_YUVA420P16: | ||
316 | case AV_PIX_FMT_YUVA422P9: | ||
317 | case AV_PIX_FMT_YUVA422P10: | ||
318 | case AV_PIX_FMT_YUVA422P16: | ||
319 | case AV_PIX_FMT_YUVA444P9: | ||
320 | case AV_PIX_FMT_YUVA444P10: | ||
321 | case AV_PIX_FMT_YUVA444P16: | ||
322 | 16 | s->version = 3; | |
323 | 16 | break; | |
324 | 4 | case AV_PIX_FMT_RGB32: | |
325 | 4 | s->bitstream_bpp = 32; | |
326 | 4 | break; | |
327 | 4 | case AV_PIX_FMT_RGB24: | |
328 | 4 | s->bitstream_bpp = 24; | |
329 | 4 | break; | |
330 | ✗ | default: | |
331 | ✗ | av_log(avctx, AV_LOG_ERROR, "format not supported\n"); | |
332 | ✗ | return AVERROR(EINVAL); | |
333 | } | ||
334 | 32 | s->n = 1<<s->bps; | |
335 | 32 | s->vlc_n = FFMIN(s->n, MAX_VLC_N); | |
336 | |||
337 | 32 | avctx->bits_per_coded_sample = s->bitstream_bpp; | |
338 |
4/6✓ Branch 0 taken 8 times.
✓ Branch 1 taken 24 times.
✓ Branch 2 taken 8 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 8 times.
✗ Branch 5 not taken.
|
32 | s->decorrelate = s->bitstream_bpp >= 24 && !s->yuv && !(desc->flags & AV_PIX_FMT_FLAG_PLANAR); |
339 | 32 | s->interlaced = avctx->flags & AV_CODEC_FLAG_INTERLACED_ME ? 1 : 0; | |
340 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 32 times.
|
32 | if (s->context) { |
341 | ✗ | if (s->flags & (AV_CODEC_FLAG_PASS1 | AV_CODEC_FLAG_PASS2)) { | |
342 | ✗ | av_log(avctx, AV_LOG_ERROR, | |
343 | "context=1 is not compatible with " | ||
344 | "2 pass huffyuv encoding\n"); | ||
345 | ✗ | return AVERROR(EINVAL); | |
346 | } | ||
347 | } | ||
348 | |||
349 |
2/2✓ Branch 0 taken 12 times.
✓ Branch 1 taken 20 times.
|
32 | if (avctx->codec->id == AV_CODEC_ID_HUFFYUV) { |
350 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 12 times.
|
12 | if (s->interlaced != ( avctx->height > 288 )) |
351 | ✗ | av_log(avctx, AV_LOG_INFO, | |
352 | "using huffyuv 2.2.0 or newer interlacing flag\n"); | ||
353 | } | ||
354 | |||
355 |
1/4✗ Branch 0 not taken.
✓ Branch 1 taken 32 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
|
32 | if (s->version > 3 && avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) { |
356 | ✗ | av_log(avctx, AV_LOG_ERROR, "Ver > 3 is under development, files encoded with it may not be decodable with future versions!!!\n" | |
357 | "Use vstrict=-2 / -strict -2 to use it anyway.\n"); | ||
358 | ✗ | return AVERROR(EINVAL); | |
359 | } | ||
360 | |||
361 |
3/6✓ Branch 0 taken 8 times.
✓ Branch 1 taken 24 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 8 times.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
|
32 | if (s->bitstream_bpp >= 24 && s->predictor == MEDIAN && s->version <= 2) { |
362 | ✗ | av_log(avctx, AV_LOG_ERROR, | |
363 | "Error: RGB is incompatible with median predictor\n"); | ||
364 | ✗ | return AVERROR(EINVAL); | |
365 | } | ||
366 | |||
367 | 32 | avctx->extradata[0] = s->predictor | (s->decorrelate << 6); | |
368 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 32 times.
|
32 | avctx->extradata[2] = s->interlaced ? 0x10 : 0x20; |
369 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 32 times.
|
32 | if (s->context) |
370 | ✗ | avctx->extradata[2] |= 0x40; | |
371 |
2/2✓ Branch 0 taken 16 times.
✓ Branch 1 taken 16 times.
|
32 | if (s->version < 3) { |
372 | 16 | avctx->extradata[1] = s->bitstream_bpp; | |
373 | 16 | avctx->extradata[3] = 0; | |
374 | } else { | ||
375 | 16 | avctx->extradata[1] = ((s->bps-1)<<4) | s->chroma_h_shift | (s->chroma_v_shift<<2); | |
376 |
1/2✓ Branch 0 taken 16 times.
✗ Branch 1 not taken.
|
16 | if (s->chroma) |
377 |
1/2✓ Branch 0 taken 16 times.
✗ Branch 1 not taken.
|
16 | avctx->extradata[2] |= s->yuv ? 1 : 2; |
378 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 16 times.
|
16 | if (s->alpha) |
379 | ✗ | avctx->extradata[2] |= 4; | |
380 | 16 | avctx->extradata[3] = 1; | |
381 | } | ||
382 | 32 | avctx->extradata_size = 4; | |
383 | |||
384 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 32 times.
|
32 | if (avctx->stats_in) { |
385 | ✗ | char *p = avctx->stats_in; | |
386 | |||
387 | ✗ | for (i = 0; i < 4; i++) | |
388 | ✗ | for (j = 0; j < s->vlc_n; j++) | |
389 | ✗ | s->stats[i][j] = 1; | |
390 | |||
391 | for (;;) { | ||
392 | ✗ | for (i = 0; i < 4; i++) { | |
393 | char *next; | ||
394 | |||
395 | ✗ | for (j = 0; j < s->vlc_n; j++) { | |
396 | ✗ | s->stats[i][j] += strtol(p, &next, 0); | |
397 | ✗ | if (next == p) return -1; | |
398 | ✗ | p = next; | |
399 | } | ||
400 | } | ||
401 | ✗ | if (p[0] == 0 || p[1] == 0 || p[2] == 0) break; | |
402 | } | ||
403 | } else { | ||
404 |
2/2✓ Branch 0 taken 128 times.
✓ Branch 1 taken 32 times.
|
160 | for (i = 0; i < 4; i++) |
405 |
2/2✓ Branch 0 taken 364544 times.
✓ Branch 1 taken 128 times.
|
364672 | for (j = 0; j < s->vlc_n; j++) { |
406 | 364544 | int d = FFMIN(j, s->vlc_n - j); | |
407 | |||
408 | 364544 | s->stats[i][j] = 100000000 / (d*d + 1); | |
409 | } | ||
410 | } | ||
411 | |||
412 | 32 | ret = store_huffman_tables(s, avctx->extradata + avctx->extradata_size); | |
413 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 32 times.
|
32 | if (ret < 0) |
414 | ✗ | return ret; | |
415 | 32 | avctx->extradata_size += ret; | |
416 | |||
417 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 32 times.
|
32 | if (s->context) { |
418 | ✗ | for (i = 0; i < 4; i++) { | |
419 | ✗ | int pels = avctx->width * avctx->height / (i ? 40 : 10); | |
420 | ✗ | for (j = 0; j < s->vlc_n; j++) { | |
421 | ✗ | int d = FFMIN(j, s->vlc_n - j); | |
422 | ✗ | s->stats[i][j] = pels/(d*d + 1); | |
423 | } | ||
424 | } | ||
425 | } else { | ||
426 |
2/2✓ Branch 0 taken 128 times.
✓ Branch 1 taken 32 times.
|
160 | for (i = 0; i < 4; i++) |
427 |
2/2✓ Branch 0 taken 364544 times.
✓ Branch 1 taken 128 times.
|
364672 | for (j = 0; j < s->vlc_n; j++) |
428 | 364544 | s->stats[i][j]= 0; | |
429 | } | ||
430 | |||
431 | 32 | ret = ff_huffyuv_alloc_temp(s->temp, s->temp16, avctx->width); | |
432 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 32 times.
|
32 | if (ret < 0) |
433 | ✗ | return ret; | |
434 | |||
435 | 32 | s->picture_number=0; | |
436 | |||
437 | 32 | return 0; | |
438 | } | ||
439 | 67350 | static int encode_422_bitstream(HYuvEncContext *s, int offset, int count) | |
440 | { | ||
441 | int i; | ||
442 | 67350 | const uint8_t *y = s->temp[0] + offset; | |
443 | 67350 | const uint8_t *u = s->temp[1] + offset / 2; | |
444 | 67350 | const uint8_t *v = s->temp[2] + offset / 2; | |
445 | |||
446 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 67350 times.
|
67350 | if (put_bytes_left(&s->pb, 0) < 2 * 4 * count) { |
447 | ✗ | av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n"); | |
448 | ✗ | return -1; | |
449 | } | ||
450 | |||
451 | #define LOAD4\ | ||
452 | int y0 = y[2 * i];\ | ||
453 | int y1 = y[2 * i + 1];\ | ||
454 | int u0 = u[i];\ | ||
455 | int v0 = v[i]; | ||
456 | |||
457 | 67350 | count /= 2; | |
458 | |||
459 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 67350 times.
|
67350 | if (s->flags & AV_CODEC_FLAG_PASS1) { |
460 | ✗ | for(i = 0; i < count; i++) { | |
461 | ✗ | LOAD4; | |
462 | ✗ | s->stats[0][y0]++; | |
463 | ✗ | s->stats[1][u0]++; | |
464 | ✗ | s->stats[0][y1]++; | |
465 | ✗ | s->stats[2][v0]++; | |
466 | } | ||
467 | } | ||
468 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 67350 times.
|
67350 | if (s->avctx->flags2 & AV_CODEC_FLAG2_NO_OUTPUT) |
469 | ✗ | return 0; | |
470 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 67350 times.
|
67350 | if (s->context) { |
471 | ✗ | for (i = 0; i < count; i++) { | |
472 | ✗ | LOAD4; | |
473 | ✗ | s->stats[0][y0]++; | |
474 | ✗ | put_bits(&s->pb, s->len[0][y0], s->bits[0][y0]); | |
475 | ✗ | s->stats[1][u0]++; | |
476 | ✗ | put_bits(&s->pb, s->len[1][u0], s->bits[1][u0]); | |
477 | ✗ | s->stats[0][y1]++; | |
478 | ✗ | put_bits(&s->pb, s->len[0][y1], s->bits[0][y1]); | |
479 | ✗ | s->stats[2][v0]++; | |
480 | ✗ | put_bits(&s->pb, s->len[2][v0], s->bits[2][v0]); | |
481 | } | ||
482 | } else { | ||
483 |
2/2✓ Branch 0 taken 11447750 times.
✓ Branch 1 taken 67350 times.
|
11515100 | for(i = 0; i < count; i++) { |
484 | 11447750 | LOAD4; | |
485 | 11447750 | put_bits(&s->pb, s->len[0][y0], s->bits[0][y0]); | |
486 | 11447750 | put_bits(&s->pb, s->len[1][u0], s->bits[1][u0]); | |
487 | 11447750 | put_bits(&s->pb, s->len[0][y1], s->bits[0][y1]); | |
488 | 11447750 | put_bits(&s->pb, s->len[2][v0], s->bits[2][v0]); | |
489 | } | ||
490 | } | ||
491 | 67350 | return 0; | |
492 | } | ||
493 | |||
494 | 493900 | static int encode_plane_bitstream(HYuvEncContext *s, int width, int plane) | |
495 | { | ||
496 | 493900 | int i, count = width/2; | |
497 | |||
498 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 493900 times.
|
493900 | if (put_bytes_left(&s->pb, 0) < count * s->bps / 2) { |
499 | ✗ | av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n"); | |
500 | ✗ | return -1; | |
501 | } | ||
502 | |||
503 | #define LOADEND\ | ||
504 | int y0 = s->temp[0][width-1]; | ||
505 | #define LOADEND_14\ | ||
506 | int y0 = s->temp16[0][width-1] & mask; | ||
507 | #define LOADEND_16\ | ||
508 | int y0 = s->temp16[0][width-1]; | ||
509 | #define STATEND\ | ||
510 | s->stats[plane][y0]++; | ||
511 | #define STATEND_16\ | ||
512 | s->stats[plane][y0>>2]++; | ||
513 | #define WRITEEND\ | ||
514 | put_bits(&s->pb, s->len[plane][y0], s->bits[plane][y0]); | ||
515 | #define WRITEEND_16\ | ||
516 | put_bits(&s->pb, s->len[plane][y0>>2], s->bits[plane][y0>>2]);\ | ||
517 | put_bits(&s->pb, 2, y0&3); | ||
518 | |||
519 | #define LOAD2\ | ||
520 | int y0 = s->temp[0][2 * i];\ | ||
521 | int y1 = s->temp[0][2 * i + 1]; | ||
522 | #define LOAD2_14\ | ||
523 | int y0 = s->temp16[0][2 * i] & mask;\ | ||
524 | int y1 = s->temp16[0][2 * i + 1] & mask; | ||
525 | #define LOAD2_16\ | ||
526 | int y0 = s->temp16[0][2 * i];\ | ||
527 | int y1 = s->temp16[0][2 * i + 1]; | ||
528 | #define STAT2\ | ||
529 | s->stats[plane][y0]++;\ | ||
530 | s->stats[plane][y1]++; | ||
531 | #define STAT2_16\ | ||
532 | s->stats[plane][y0>>2]++;\ | ||
533 | s->stats[plane][y1>>2]++; | ||
534 | #define WRITE2\ | ||
535 | put_bits(&s->pb, s->len[plane][y0], s->bits[plane][y0]);\ | ||
536 | put_bits(&s->pb, s->len[plane][y1], s->bits[plane][y1]); | ||
537 | #define WRITE2_16\ | ||
538 | put_bits(&s->pb, s->len[plane][y0>>2], s->bits[plane][y0>>2]);\ | ||
539 | put_bits(&s->pb, 2, y0&3);\ | ||
540 | put_bits(&s->pb, s->len[plane][y1>>2], s->bits[plane][y1>>2]);\ | ||
541 | put_bits(&s->pb, 2, y1&3); | ||
542 | |||
543 |
2/2✓ Branch 0 taken 134700 times.
✓ Branch 1 taken 359200 times.
|
493900 | if (s->bps <= 8) { |
544 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 134700 times.
|
134700 | if (s->flags & AV_CODEC_FLAG_PASS1) { |
545 | ✗ | for (i = 0; i < count; i++) { | |
546 | ✗ | LOAD2; | |
547 | ✗ | STAT2; | |
548 | } | ||
549 | ✗ | if (width&1) { | |
550 | ✗ | LOADEND; | |
551 | ✗ | STATEND; | |
552 | } | ||
553 | } | ||
554 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 134700 times.
|
134700 | if (s->avctx->flags2 & AV_CODEC_FLAG2_NO_OUTPUT) |
555 | ✗ | return 0; | |
556 | |||
557 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 134700 times.
|
134700 | if (s->context) { |
558 | ✗ | for (i = 0; i < count; i++) { | |
559 | ✗ | LOAD2; | |
560 | ✗ | STAT2; | |
561 | ✗ | WRITE2; | |
562 | } | ||
563 | ✗ | if (width&1) { | |
564 | ✗ | LOADEND; | |
565 | ✗ | STATEND; | |
566 | ✗ | WRITEEND; | |
567 | } | ||
568 | } else { | ||
569 |
2/2✓ Branch 0 taken 22896300 times.
✓ Branch 1 taken 134700 times.
|
23031000 | for (i = 0; i < count; i++) { |
570 | 22896300 | LOAD2; | |
571 | 22896300 | WRITE2; | |
572 | } | ||
573 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 134700 times.
|
134700 | if (width&1) { |
574 | ✗ | LOADEND; | |
575 | ✗ | WRITEEND; | |
576 | } | ||
577 | } | ||
578 |
2/2✓ Branch 0 taken 224500 times.
✓ Branch 1 taken 134700 times.
|
359200 | } else if (s->bps <= 14) { |
579 | 224500 | int mask = s->n - 1; | |
580 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 224500 times.
|
224500 | if (s->flags & AV_CODEC_FLAG_PASS1) { |
581 | ✗ | for (i = 0; i < count; i++) { | |
582 | ✗ | LOAD2_14; | |
583 | ✗ | STAT2; | |
584 | } | ||
585 | ✗ | if (width&1) { | |
586 | ✗ | LOADEND_14; | |
587 | ✗ | STATEND; | |
588 | } | ||
589 | } | ||
590 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 224500 times.
|
224500 | if (s->avctx->flags2 & AV_CODEC_FLAG2_NO_OUTPUT) |
591 | ✗ | return 0; | |
592 | |||
593 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 224500 times.
|
224500 | if (s->context) { |
594 | ✗ | for (i = 0; i < count; i++) { | |
595 | ✗ | LOAD2_14; | |
596 | ✗ | STAT2; | |
597 | ✗ | WRITE2; | |
598 | } | ||
599 | ✗ | if (width&1) { | |
600 | ✗ | LOADEND_14; | |
601 | ✗ | STATEND; | |
602 | ✗ | WRITEEND; | |
603 | } | ||
604 | } else { | ||
605 |
2/2✓ Branch 0 taken 26709800 times.
✓ Branch 1 taken 224500 times.
|
26934300 | for (i = 0; i < count; i++) { |
606 | 26709800 | LOAD2_14; | |
607 | 26709800 | WRITE2; | |
608 | } | ||
609 |
2/2✓ Branch 0 taken 5100 times.
✓ Branch 1 taken 219400 times.
|
224500 | if (width&1) { |
610 | 5100 | LOADEND_14; | |
611 | 5100 | WRITEEND; | |
612 | } | ||
613 | } | ||
614 | } else { | ||
615 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 134700 times.
|
134700 | if (s->flags & AV_CODEC_FLAG_PASS1) { |
616 | ✗ | for (i = 0; i < count; i++) { | |
617 | ✗ | LOAD2_16; | |
618 | ✗ | STAT2_16; | |
619 | } | ||
620 | ✗ | if (width&1) { | |
621 | ✗ | LOADEND_16; | |
622 | ✗ | STATEND_16; | |
623 | } | ||
624 | } | ||
625 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 134700 times.
|
134700 | if (s->avctx->flags2 & AV_CODEC_FLAG2_NO_OUTPUT) |
626 | ✗ | return 0; | |
627 | |||
628 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 134700 times.
|
134700 | if (s->context) { |
629 | ✗ | for (i = 0; i < count; i++) { | |
630 | ✗ | LOAD2_16; | |
631 | ✗ | STAT2_16; | |
632 | ✗ | WRITE2_16; | |
633 | } | ||
634 | ✗ | if (width&1) { | |
635 | ✗ | LOADEND_16; | |
636 | ✗ | STATEND_16; | |
637 | ✗ | WRITEEND_16; | |
638 | } | ||
639 | } else { | ||
640 |
2/2✓ Branch 0 taken 22896300 times.
✓ Branch 1 taken 134700 times.
|
23031000 | for (i = 0; i < count; i++) { |
641 | 22896300 | LOAD2_16; | |
642 | 22896300 | WRITE2_16; | |
643 | } | ||
644 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 134700 times.
|
134700 | if (width&1) { |
645 | ✗ | LOADEND_16; | |
646 | ✗ | WRITEEND_16; | |
647 | } | ||
648 | } | ||
649 | } | ||
650 | #undef LOAD2 | ||
651 | #undef STAT2 | ||
652 | #undef WRITE2 | ||
653 | 493900 | return 0; | |
654 | } | ||
655 | |||
656 | 22450 | static int encode_gray_bitstream(HYuvEncContext *s, int count) | |
657 | { | ||
658 | int i; | ||
659 | |||
660 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 22450 times.
|
22450 | if (put_bytes_left(&s->pb, 0) < 4 * count) { |
661 | ✗ | av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n"); | |
662 | ✗ | return -1; | |
663 | } | ||
664 | |||
665 | #define LOAD2\ | ||
666 | int y0 = s->temp[0][2 * i];\ | ||
667 | int y1 = s->temp[0][2 * i + 1]; | ||
668 | #define STAT2\ | ||
669 | s->stats[0][y0]++;\ | ||
670 | s->stats[0][y1]++; | ||
671 | #define WRITE2\ | ||
672 | put_bits(&s->pb, s->len[0][y0], s->bits[0][y0]);\ | ||
673 | put_bits(&s->pb, s->len[0][y1], s->bits[0][y1]); | ||
674 | |||
675 | 22450 | count /= 2; | |
676 | |||
677 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 22450 times.
|
22450 | if (s->flags & AV_CODEC_FLAG_PASS1) { |
678 | ✗ | for (i = 0; i < count; i++) { | |
679 | ✗ | LOAD2; | |
680 | ✗ | STAT2; | |
681 | } | ||
682 | } | ||
683 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 22450 times.
|
22450 | if (s->avctx->flags2 & AV_CODEC_FLAG2_NO_OUTPUT) |
684 | ✗ | return 0; | |
685 | |||
686 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 22450 times.
|
22450 | if (s->context) { |
687 | ✗ | for (i = 0; i < count; i++) { | |
688 | ✗ | LOAD2; | |
689 | ✗ | STAT2; | |
690 | ✗ | WRITE2; | |
691 | } | ||
692 | } else { | ||
693 |
2/2✓ Branch 0 taken 3816050 times.
✓ Branch 1 taken 22450 times.
|
3838500 | for (i = 0; i < count; i++) { |
694 | 3816050 | LOAD2; | |
695 | 3816050 | WRITE2; | |
696 | } | ||
697 | } | ||
698 | 22450 | return 0; | |
699 | } | ||
700 | |||
701 | 89800 | static inline int encode_bgra_bitstream(HYuvEncContext *s, int count, int planes) | |
702 | { | ||
703 | int i; | ||
704 | |||
705 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 89800 times.
|
89800 | if (put_bytes_left(&s->pb, 0) < 4 * planes * count) { |
706 | ✗ | av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n"); | |
707 | ✗ | return -1; | |
708 | } | ||
709 | |||
710 | #define LOAD_GBRA \ | ||
711 | int g = s->temp[0][planes == 3 ? 3 * i + 1 : 4 * i + G]; \ | ||
712 | int b =(s->temp[0][planes == 3 ? 3 * i + 2 : 4 * i + B] - g) & 0xFF;\ | ||
713 | int r =(s->temp[0][planes == 3 ? 3 * i + 0 : 4 * i + R] - g) & 0xFF;\ | ||
714 | int a = s->temp[0][planes * i + A]; | ||
715 | |||
716 | #define STAT_BGRA \ | ||
717 | s->stats[0][b]++; \ | ||
718 | s->stats[1][g]++; \ | ||
719 | s->stats[2][r]++; \ | ||
720 | if (planes == 4) \ | ||
721 | s->stats[2][a]++; | ||
722 | |||
723 | #define WRITE_GBRA \ | ||
724 | put_bits(&s->pb, s->len[1][g], s->bits[1][g]); \ | ||
725 | put_bits(&s->pb, s->len[0][b], s->bits[0][b]); \ | ||
726 | put_bits(&s->pb, s->len[2][r], s->bits[2][r]); \ | ||
727 | if (planes == 4) \ | ||
728 | put_bits(&s->pb, s->len[2][a], s->bits[2][a]); | ||
729 | |||
730 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 89800 times.
|
89800 | if ((s->flags & AV_CODEC_FLAG_PASS1) && |
731 | ✗ | (s->avctx->flags2 & AV_CODEC_FLAG2_NO_OUTPUT)) { | |
732 | ✗ | for (i = 0; i < count; i++) { | |
733 | ✗ | LOAD_GBRA; | |
734 | ✗ | STAT_BGRA; | |
735 | } | ||
736 |
2/4✓ Branch 0 taken 89800 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 89800 times.
|
89800 | } else if (s->context || (s->flags & AV_CODEC_FLAG_PASS1)) { |
737 | ✗ | for (i = 0; i < count; i++) { | |
738 | ✗ | LOAD_GBRA; | |
739 | ✗ | STAT_BGRA; | |
740 | ✗ | WRITE_GBRA; | |
741 | } | ||
742 | } else { | ||
743 |
2/2✓ Branch 0 taken 30528000 times.
✓ Branch 1 taken 89800 times.
|
30617800 | for (i = 0; i < count; i++) { |
744 |
6/6✓ Branch 0 taken 15264000 times.
✓ Branch 1 taken 15264000 times.
✓ Branch 2 taken 15264000 times.
✓ Branch 3 taken 15264000 times.
✓ Branch 4 taken 15264000 times.
✓ Branch 5 taken 15264000 times.
|
30528000 | LOAD_GBRA; |
745 |
2/2✓ Branch 3 taken 15264000 times.
✓ Branch 4 taken 15264000 times.
|
30528000 | WRITE_GBRA; |
746 | } | ||
747 | } | ||
748 | 89800 | return 0; | |
749 | } | ||
750 | |||
751 | 1600 | static int encode_frame(AVCodecContext *avctx, AVPacket *pkt, | |
752 | const AVFrame *pict, int *got_packet) | ||
753 | { | ||
754 | 1600 | HYuvEncContext *s = avctx->priv_data; | |
755 | 1600 | const int width = avctx->width; | |
756 | 1600 | const int width2 = avctx->width >> 1; | |
757 | 1600 | const int height = avctx->height; | |
758 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1600 times.
|
1600 | const int fake_ystride = s->interlaced ? pict->linesize[0]*2 : pict->linesize[0]; |
759 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1600 times.
|
1600 | const int fake_ustride = s->interlaced ? pict->linesize[1]*2 : pict->linesize[1]; |
760 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1600 times.
|
1600 | const int fake_vstride = s->interlaced ? pict->linesize[2]*2 : pict->linesize[2]; |
761 | 1600 | const AVFrame * const p = pict; | |
762 | 1600 | int i, j, size = 0, ret; | |
763 | |||
764 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 1600 times.
|
1600 | if ((ret = ff_alloc_packet(avctx, pkt, width * height * 3 * 4 + AV_INPUT_BUFFER_MIN_SIZE)) < 0) |
765 | ✗ | return ret; | |
766 | |||
767 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1600 times.
|
1600 | if (s->context) { |
768 | ✗ | size = store_huffman_tables(s, pkt->data); | |
769 | ✗ | if (size < 0) | |
770 | ✗ | return size; | |
771 | |||
772 | ✗ | for (i = 0; i < 4; i++) | |
773 | ✗ | for (j = 0; j < s->vlc_n; j++) | |
774 | ✗ | s->stats[i][j] >>= 1; | |
775 | } | ||
776 | |||
777 | 1600 | init_put_bits(&s->pb, pkt->data + size, pkt->size - size); | |
778 | |||
779 |
2/2✓ Branch 0 taken 1400 times.
✓ Branch 1 taken 200 times.
|
1600 | if (avctx->pix_fmt == AV_PIX_FMT_YUV422P || |
780 |
2/2✓ Branch 0 taken 200 times.
✓ Branch 1 taken 1200 times.
|
1800 | avctx->pix_fmt == AV_PIX_FMT_YUV420P) { |
781 | int lefty, leftu, leftv, y, cy; | ||
782 | |||
783 | 400 | put_bits(&s->pb, 8, leftv = p->data[2][0]); | |
784 | 400 | put_bits(&s->pb, 8, lefty = p->data[0][1]); | |
785 | 400 | put_bits(&s->pb, 8, leftu = p->data[1][0]); | |
786 | 400 | put_bits(&s->pb, 8, p->data[0][0]); | |
787 | |||
788 | 400 | lefty = sub_left_prediction(s, s->temp[0], p->data[0], width , 0); | |
789 | 400 | leftu = sub_left_prediction(s, s->temp[1], p->data[1], width2, 0); | |
790 | 400 | leftv = sub_left_prediction(s, s->temp[2], p->data[2], width2, 0); | |
791 | |||
792 | 400 | encode_422_bitstream(s, 2, width-2); | |
793 | |||
794 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 400 times.
|
400 | if (s->predictor==MEDIAN) { |
795 | int lefttopy, lefttopu, lefttopv; | ||
796 | ✗ | cy = y = 1; | |
797 | ✗ | if (s->interlaced) { | |
798 | ✗ | lefty = sub_left_prediction(s, s->temp[0], p->data[0] + p->linesize[0], width , lefty); | |
799 | ✗ | leftu = sub_left_prediction(s, s->temp[1], p->data[1] + p->linesize[1], width2, leftu); | |
800 | ✗ | leftv = sub_left_prediction(s, s->temp[2], p->data[2] + p->linesize[2], width2, leftv); | |
801 | |||
802 | ✗ | encode_422_bitstream(s, 0, width); | |
803 | ✗ | y++; cy++; | |
804 | } | ||
805 | |||
806 | ✗ | lefty = sub_left_prediction(s, s->temp[0], p->data[0] + fake_ystride, 4, lefty); | |
807 | ✗ | leftu = sub_left_prediction(s, s->temp[1], p->data[1] + fake_ustride, 2, leftu); | |
808 | ✗ | leftv = sub_left_prediction(s, s->temp[2], p->data[2] + fake_vstride, 2, leftv); | |
809 | |||
810 | ✗ | encode_422_bitstream(s, 0, 4); | |
811 | |||
812 | ✗ | lefttopy = p->data[0][3]; | |
813 | ✗ | lefttopu = p->data[1][1]; | |
814 | ✗ | lefttopv = p->data[2][1]; | |
815 | ✗ | s->llvidencdsp.sub_median_pred(s->temp[0], p->data[0] + 4, p->data[0] + fake_ystride + 4, width - 4, &lefty, &lefttopy); | |
816 | ✗ | s->llvidencdsp.sub_median_pred(s->temp[1], p->data[1] + 2, p->data[1] + fake_ustride + 2, width2 - 2, &leftu, &lefttopu); | |
817 | ✗ | s->llvidencdsp.sub_median_pred(s->temp[2], p->data[2] + 2, p->data[2] + fake_vstride + 2, width2 - 2, &leftv, &lefttopv); | |
818 | ✗ | encode_422_bitstream(s, 0, width - 4); | |
819 | ✗ | y++; cy++; | |
820 | |||
821 | ✗ | for (; y < height; y++,cy++) { | |
822 | const uint8_t *ydst, *udst, *vdst; | ||
823 | |||
824 | ✗ | if (s->bitstream_bpp == 12) { | |
825 | ✗ | while (2 * cy > y) { | |
826 | ✗ | ydst = p->data[0] + p->linesize[0] * y; | |
827 | ✗ | s->llvidencdsp.sub_median_pred(s->temp[0], ydst - fake_ystride, ydst, width, &lefty, &lefttopy); | |
828 | ✗ | encode_gray_bitstream(s, width); | |
829 | ✗ | y++; | |
830 | } | ||
831 | ✗ | if (y >= height) break; | |
832 | } | ||
833 | ✗ | ydst = p->data[0] + p->linesize[0] * y; | |
834 | ✗ | udst = p->data[1] + p->linesize[1] * cy; | |
835 | ✗ | vdst = p->data[2] + p->linesize[2] * cy; | |
836 | |||
837 | ✗ | s->llvidencdsp.sub_median_pred(s->temp[0], ydst - fake_ystride, ydst, width, &lefty, &lefttopy); | |
838 | ✗ | s->llvidencdsp.sub_median_pred(s->temp[1], udst - fake_ustride, udst, width2, &leftu, &lefttopu); | |
839 | ✗ | s->llvidencdsp.sub_median_pred(s->temp[2], vdst - fake_vstride, vdst, width2, &leftv, &lefttopv); | |
840 | |||
841 | ✗ | encode_422_bitstream(s, 0, width); | |
842 | } | ||
843 | } else { | ||
844 |
2/2✓ Branch 0 taken 67150 times.
✓ Branch 1 taken 200 times.
|
67350 | for (cy = y = 1; y < height; y++, cy++) { |
845 | const uint8_t *ydst, *udst, *vdst; | ||
846 | |||
847 | /* encode a luma only line & y++ */ | ||
848 |
2/2✓ Branch 0 taken 22450 times.
✓ Branch 1 taken 44700 times.
|
67150 | if (s->bitstream_bpp == 12) { |
849 | 22450 | ydst = p->data[0] + p->linesize[0] * y; | |
850 | |||
851 |
1/4✗ Branch 0 not taken.
✓ Branch 1 taken 22450 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
|
22450 | if (s->predictor == PLANE && s->interlaced < y) { |
852 | ✗ | s->llvidencdsp.diff_bytes(s->temp[1], ydst, ydst - fake_ystride, width); | |
853 | |||
854 | ✗ | lefty = sub_left_prediction(s, s->temp[0], s->temp[1], width , lefty); | |
855 | } else { | ||
856 | 22450 | lefty = sub_left_prediction(s, s->temp[0], ydst, width , lefty); | |
857 | } | ||
858 | 22450 | encode_gray_bitstream(s, width); | |
859 | 22450 | y++; | |
860 |
2/2✓ Branch 0 taken 200 times.
✓ Branch 1 taken 22250 times.
|
22450 | if (y >= height) break; |
861 | } | ||
862 | |||
863 | 66950 | ydst = p->data[0] + p->linesize[0] * y; | |
864 | 66950 | udst = p->data[1] + p->linesize[1] * cy; | |
865 | 66950 | vdst = p->data[2] + p->linesize[2] * cy; | |
866 | |||
867 |
1/4✗ Branch 0 not taken.
✓ Branch 1 taken 66950 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
|
66950 | if (s->predictor == PLANE && s->interlaced < cy) { |
868 | ✗ | s->llvidencdsp.diff_bytes(s->temp[1], ydst, ydst - fake_ystride, width); | |
869 | ✗ | s->llvidencdsp.diff_bytes(s->temp[2], udst, udst - fake_ustride, width2); | |
870 | ✗ | s->llvidencdsp.diff_bytes(s->temp[2] + width2, vdst, vdst - fake_vstride, width2); | |
871 | |||
872 | ✗ | lefty = sub_left_prediction(s, s->temp[0], s->temp[1], width , lefty); | |
873 | ✗ | leftu = sub_left_prediction(s, s->temp[1], s->temp[2], width2, leftu); | |
874 | ✗ | leftv = sub_left_prediction(s, s->temp[2], s->temp[2] + width2, width2, leftv); | |
875 | } else { | ||
876 | 66950 | lefty = sub_left_prediction(s, s->temp[0], ydst, width , lefty); | |
877 | 66950 | leftu = sub_left_prediction(s, s->temp[1], udst, width2, leftu); | |
878 | 66950 | leftv = sub_left_prediction(s, s->temp[2], vdst, width2, leftv); | |
879 | } | ||
880 | |||
881 | 66950 | encode_422_bitstream(s, 0, width); | |
882 | } | ||
883 | } | ||
884 |
2/2✓ Branch 0 taken 200 times.
✓ Branch 1 taken 1000 times.
|
1200 | } else if(avctx->pix_fmt == AV_PIX_FMT_RGB32) { |
885 | 200 | const uint8_t *data = p->data[0] + (height - 1) * p->linesize[0]; | |
886 | 200 | const int stride = -p->linesize[0]; | |
887 | 200 | const int fake_stride = -fake_ystride; | |
888 | int leftr, leftg, leftb, lefta; | ||
889 | |||
890 | 200 | put_bits(&s->pb, 8, lefta = data[A]); | |
891 | 200 | put_bits(&s->pb, 8, leftr = data[R]); | |
892 | 200 | put_bits(&s->pb, 8, leftg = data[G]); | |
893 | 200 | put_bits(&s->pb, 8, leftb = data[B]); | |
894 | |||
895 | 200 | sub_left_prediction_bgr32(s, s->temp[0], data + 4, width - 1, | |
896 | &leftr, &leftg, &leftb, &lefta); | ||
897 | 200 | encode_bgra_bitstream(s, width - 1, 4); | |
898 | |||
899 |
2/2✓ Branch 0 taken 44700 times.
✓ Branch 1 taken 200 times.
|
44900 | for (int y = 1; y < height; y++) { |
900 | 44700 | const uint8_t *dst = data + y*stride; | |
901 |
1/4✗ Branch 0 not taken.
✓ Branch 1 taken 44700 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
|
44700 | if (s->predictor == PLANE && s->interlaced < y) { |
902 | ✗ | s->llvidencdsp.diff_bytes(s->temp[1], dst, dst - fake_stride, width * 4); | |
903 | ✗ | sub_left_prediction_bgr32(s, s->temp[0], s->temp[1], width, | |
904 | &leftr, &leftg, &leftb, &lefta); | ||
905 | } else { | ||
906 | 44700 | sub_left_prediction_bgr32(s, s->temp[0], dst, width, | |
907 | &leftr, &leftg, &leftb, &lefta); | ||
908 | } | ||
909 | 44700 | encode_bgra_bitstream(s, width, 4); | |
910 | } | ||
911 |
2/2✓ Branch 0 taken 200 times.
✓ Branch 1 taken 800 times.
|
1000 | } else if (avctx->pix_fmt == AV_PIX_FMT_RGB24) { |
912 | 200 | const uint8_t *data = p->data[0] + (height - 1) * p->linesize[0]; | |
913 | 200 | const int stride = -p->linesize[0]; | |
914 | 200 | const int fake_stride = -fake_ystride; | |
915 | int leftr, leftg, leftb; | ||
916 | |||
917 | 200 | put_bits(&s->pb, 8, leftr = data[0]); | |
918 | 200 | put_bits(&s->pb, 8, leftg = data[1]); | |
919 | 200 | put_bits(&s->pb, 8, leftb = data[2]); | |
920 | 200 | put_bits(&s->pb, 8, 0); | |
921 | |||
922 | 200 | sub_left_prediction_rgb24(s, s->temp[0], data + 3, width - 1, | |
923 | &leftr, &leftg, &leftb); | ||
924 | 200 | encode_bgra_bitstream(s, width-1, 3); | |
925 | |||
926 |
2/2✓ Branch 0 taken 44700 times.
✓ Branch 1 taken 200 times.
|
44900 | for (int y = 1; y < height; y++) { |
927 | 44700 | const uint8_t *dst = data + y * stride; | |
928 |
1/4✗ Branch 0 not taken.
✓ Branch 1 taken 44700 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
|
44700 | if (s->predictor == PLANE && s->interlaced < y) { |
929 | ✗ | s->llvidencdsp.diff_bytes(s->temp[1], dst, dst - fake_stride, | |
930 | ✗ | width * 3); | |
931 | ✗ | sub_left_prediction_rgb24(s, s->temp[0], s->temp[1], width, | |
932 | &leftr, &leftg, &leftb); | ||
933 | } else { | ||
934 | 44700 | sub_left_prediction_rgb24(s, s->temp[0], dst, width, | |
935 | &leftr, &leftg, &leftb); | ||
936 | } | ||
937 | 44700 | encode_bgra_bitstream(s, width, 3); | |
938 | } | ||
939 |
1/2✓ Branch 0 taken 800 times.
✗ Branch 1 not taken.
|
800 | } else if (s->version > 2) { |
940 | int plane; | ||
941 |
2/2✓ Branch 0 taken 2400 times.
✓ Branch 1 taken 800 times.
|
3200 | for (plane = 0; plane < 1 + 2*s->chroma + s->alpha; plane++) { |
942 | int left, y; | ||
943 | 2400 | int w = width; | |
944 | 2400 | int h = height; | |
945 | 2400 | int fake_stride = fake_ystride; | |
946 | |||
947 |
5/6✓ Branch 0 taken 2400 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1600 times.
✓ Branch 3 taken 800 times.
✓ Branch 4 taken 800 times.
✓ Branch 5 taken 800 times.
|
2400 | if (s->chroma && (plane == 1 || plane == 2)) { |
948 | 1600 | w >>= s->chroma_h_shift; | |
949 | 1600 | h >>= s->chroma_v_shift; | |
950 |
2/2✓ Branch 0 taken 800 times.
✓ Branch 1 taken 800 times.
|
1600 | fake_stride = plane == 1 ? fake_ustride : fake_vstride; |
951 | } | ||
952 | |||
953 | 2400 | left = sub_left_prediction(s, s->temp[0], p->data[plane], w , 0); | |
954 | |||
955 | 2400 | encode_plane_bitstream(s, w, plane); | |
956 | |||
957 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2400 times.
|
2400 | if (s->predictor==MEDIAN) { |
958 | int lefttop; | ||
959 | ✗ | y = 1; | |
960 | ✗ | if (s->interlaced) { | |
961 | ✗ | left = sub_left_prediction(s, s->temp[0], p->data[plane] + p->linesize[plane], w , left); | |
962 | |||
963 | ✗ | encode_plane_bitstream(s, w, plane); | |
964 | ✗ | y++; | |
965 | } | ||
966 | |||
967 | ✗ | lefttop = p->data[plane][0]; | |
968 | |||
969 | ✗ | for (; y < h; y++) { | |
970 | ✗ | const uint8_t *dst = p->data[plane] + p->linesize[plane] * y; | |
971 | |||
972 | ✗ | sub_median_prediction(s, s->temp[0], dst - fake_stride, dst, w , &left, &lefttop); | |
973 | |||
974 | ✗ | encode_plane_bitstream(s, w, plane); | |
975 | } | ||
976 | } else { | ||
977 |
2/2✓ Branch 0 taken 491500 times.
✓ Branch 1 taken 2400 times.
|
493900 | for (y = 1; y < h; y++) { |
978 | 491500 | const uint8_t *dst = p->data[plane] + p->linesize[plane] * y; | |
979 | |||
980 |
3/4✓ Branch 0 taken 134100 times.
✓ Branch 1 taken 357400 times.
✓ Branch 2 taken 134100 times.
✗ Branch 3 not taken.
|
491500 | if (s->predictor == PLANE && s->interlaced < y) { |
981 | 134100 | diff_bytes(s, s->temp[1], dst, dst - fake_stride, w); | |
982 | |||
983 | 134100 | left = sub_left_prediction(s, s->temp[0], s->temp[1], w , left); | |
984 | } else { | ||
985 | 357400 | left = sub_left_prediction(s, s->temp[0], dst, w , left); | |
986 | } | ||
987 | |||
988 | 491500 | encode_plane_bitstream(s, w, plane); | |
989 | } | ||
990 | } | ||
991 | } | ||
992 | } else { | ||
993 | ✗ | av_log(avctx, AV_LOG_ERROR, "Format not supported!\n"); | |
994 | } | ||
995 | 1600 | emms_c(); | |
996 | |||
997 | 1600 | size += (put_bits_count(&s->pb) + 31) / 8; | |
998 | 1600 | put_bits(&s->pb, 16, 0); | |
999 | 1600 | put_bits(&s->pb, 15, 0); | |
1000 | 1600 | size /= 4; | |
1001 | |||
1002 |
1/4✗ Branch 0 not taken.
✓ Branch 1 taken 1600 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
|
1600 | if ((s->flags & AV_CODEC_FLAG_PASS1) && (s->picture_number & 31) == 0) { |
1003 | int j; | ||
1004 | ✗ | char *p = avctx->stats_out; | |
1005 | ✗ | char *end = p + STATS_OUT_SIZE; | |
1006 | ✗ | for (i = 0; i < 4; i++) { | |
1007 | ✗ | for (j = 0; j < s->vlc_n; j++) { | |
1008 | ✗ | snprintf(p, end-p, "%"PRIu64" ", s->stats[i][j]); | |
1009 | ✗ | p += strlen(p); | |
1010 | ✗ | s->stats[i][j]= 0; | |
1011 | } | ||
1012 | ✗ | snprintf(p, end-p, "\n"); | |
1013 | ✗ | p++; | |
1014 | ✗ | if (end <= p) | |
1015 | ✗ | return AVERROR(ENOMEM); | |
1016 | } | ||
1017 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1600 times.
|
1600 | } else if (avctx->stats_out) |
1018 | ✗ | avctx->stats_out[0] = '\0'; | |
1019 |
1/2✓ Branch 0 taken 1600 times.
✗ Branch 1 not taken.
|
1600 | if (!(s->avctx->flags2 & AV_CODEC_FLAG2_NO_OUTPUT)) { |
1020 | 1600 | flush_put_bits(&s->pb); | |
1021 | 1600 | s->bdsp.bswap_buf((uint32_t *) pkt->data, (uint32_t *) pkt->data, size); | |
1022 | } | ||
1023 | |||
1024 | 1600 | s->picture_number++; | |
1025 | |||
1026 | 1600 | pkt->size = size * 4; | |
1027 | 1600 | *got_packet = 1; | |
1028 | |||
1029 | 1600 | return 0; | |
1030 | } | ||
1031 | |||
1032 | 32 | static av_cold int encode_end(AVCodecContext *avctx) | |
1033 | { | ||
1034 | 32 | HYuvEncContext *s = avctx->priv_data; | |
1035 | |||
1036 | 32 | ff_huffyuv_common_end(s->temp, s->temp16); | |
1037 | |||
1038 | 32 | av_freep(&avctx->stats_out); | |
1039 | |||
1040 | 32 | return 0; | |
1041 | } | ||
1042 | |||
1043 | #define OFFSET(x) offsetof(HYuvEncContext, x) | ||
1044 | #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM | ||
1045 | |||
1046 | #define COMMON_OPTIONS \ | ||
1047 | { "non_deterministic", "Allow multithreading for e.g. context=1 at the expense of determinism", \ | ||
1048 | OFFSET(non_determ), AV_OPT_TYPE_BOOL, { .i64 = 0 }, \ | ||
1049 | 0, 1, VE }, \ | ||
1050 | { "pred", "Prediction method", OFFSET(predictor), AV_OPT_TYPE_INT, { .i64 = LEFT }, LEFT, MEDIAN, VE, "pred" }, \ | ||
1051 | { "left", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = LEFT }, INT_MIN, INT_MAX, VE, "pred" }, \ | ||
1052 | { "plane", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = PLANE }, INT_MIN, INT_MAX, VE, "pred" }, \ | ||
1053 | { "median", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = MEDIAN }, INT_MIN, INT_MAX, VE, "pred" }, \ | ||
1054 | |||
1055 | static const AVOption normal_options[] = { | ||
1056 | COMMON_OPTIONS | ||
1057 | { NULL }, | ||
1058 | }; | ||
1059 | |||
1060 | static const AVOption ff_options[] = { | ||
1061 | COMMON_OPTIONS | ||
1062 | { "context", "Set per-frame huffman tables", OFFSET(context), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE }, | ||
1063 | { NULL }, | ||
1064 | }; | ||
1065 | |||
1066 | static const AVClass normal_class = { | ||
1067 | .class_name = "huffyuv", | ||
1068 | .item_name = av_default_item_name, | ||
1069 | .option = normal_options, | ||
1070 | .version = LIBAVUTIL_VERSION_INT, | ||
1071 | }; | ||
1072 | |||
1073 | static const AVClass ff_class = { | ||
1074 | .class_name = "ffvhuff", | ||
1075 | .item_name = av_default_item_name, | ||
1076 | .option = ff_options, | ||
1077 | .version = LIBAVUTIL_VERSION_INT, | ||
1078 | }; | ||
1079 | |||
1080 | const FFCodec ff_huffyuv_encoder = { | ||
1081 | .p.name = "huffyuv", | ||
1082 | CODEC_LONG_NAME("Huffyuv / HuffYUV"), | ||
1083 | .p.type = AVMEDIA_TYPE_VIDEO, | ||
1084 | .p.id = AV_CODEC_ID_HUFFYUV, | ||
1085 | .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS | | ||
1086 | AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE, | ||
1087 | .priv_data_size = sizeof(HYuvEncContext), | ||
1088 | .init = encode_init, | ||
1089 | FF_CODEC_ENCODE_CB(encode_frame), | ||
1090 | .close = encode_end, | ||
1091 | .p.priv_class = &normal_class, | ||
1092 | .p.pix_fmts = (const enum AVPixelFormat[]){ | ||
1093 | AV_PIX_FMT_YUV422P, AV_PIX_FMT_RGB24, | ||
1094 | AV_PIX_FMT_RGB32, AV_PIX_FMT_NONE | ||
1095 | }, | ||
1096 | .caps_internal = FF_CODEC_CAP_INIT_CLEANUP, | ||
1097 | }; | ||
1098 | |||
1099 | #if CONFIG_FFVHUFF_ENCODER | ||
1100 | const FFCodec ff_ffvhuff_encoder = { | ||
1101 | .p.name = "ffvhuff", | ||
1102 | CODEC_LONG_NAME("Huffyuv FFmpeg variant"), | ||
1103 | .p.type = AVMEDIA_TYPE_VIDEO, | ||
1104 | .p.id = AV_CODEC_ID_FFVHUFF, | ||
1105 | .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS | | ||
1106 | AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE, | ||
1107 | .priv_data_size = sizeof(HYuvEncContext), | ||
1108 | .init = encode_init, | ||
1109 | FF_CODEC_ENCODE_CB(encode_frame), | ||
1110 | .close = encode_end, | ||
1111 | .p.priv_class = &ff_class, | ||
1112 | .p.pix_fmts = (const enum AVPixelFormat[]){ | ||
1113 | AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUV411P, | ||
1114 | AV_PIX_FMT_YUV410P, AV_PIX_FMT_YUV440P, | ||
1115 | AV_PIX_FMT_GBRP, | ||
1116 | AV_PIX_FMT_GBRP9, AV_PIX_FMT_GBRP10, AV_PIX_FMT_GBRP12, AV_PIX_FMT_GBRP14, AV_PIX_FMT_GBRP16, | ||
1117 | AV_PIX_FMT_GRAY8, AV_PIX_FMT_GRAY16, | ||
1118 | AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUVA444P, | ||
1119 | AV_PIX_FMT_GBRAP, | ||
1120 | AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV420P12, AV_PIX_FMT_YUV420P14, AV_PIX_FMT_YUV420P16, | ||
1121 | AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV422P12, AV_PIX_FMT_YUV422P14, AV_PIX_FMT_YUV422P16, | ||
1122 | AV_PIX_FMT_YUV444P9, AV_PIX_FMT_YUV444P10, AV_PIX_FMT_YUV444P12, AV_PIX_FMT_YUV444P14, AV_PIX_FMT_YUV444P16, | ||
1123 | AV_PIX_FMT_YUVA420P9, AV_PIX_FMT_YUVA420P10, AV_PIX_FMT_YUVA420P16, | ||
1124 | AV_PIX_FMT_YUVA422P9, AV_PIX_FMT_YUVA422P10, AV_PIX_FMT_YUVA422P16, | ||
1125 | AV_PIX_FMT_YUVA444P9, AV_PIX_FMT_YUVA444P10, AV_PIX_FMT_YUVA444P16, | ||
1126 | AV_PIX_FMT_RGB24, | ||
1127 | AV_PIX_FMT_RGB32, AV_PIX_FMT_NONE | ||
1128 | }, | ||
1129 | .caps_internal = FF_CODEC_CAP_INIT_CLEANUP, | ||
1130 | }; | ||
1131 | #endif | ||
1132 |