avcodec/huffyuv: add YUVA420P, YUVA422P, YUVA444P, GBRAP, GRAY8A
[ffmpeg.git] / libavcodec / huffyuvenc.c
1 /*
2  * Copyright (c) 2002-2003 Michael Niedermayer <michaelni@gmx.at>
3  *
4  * see http://www.pcisys.net/~melanson/codecs/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
24 /**
25  * @file
26  * huffyuv encoder
27  */
28
29 #include "avcodec.h"
30 #include "huffyuv.h"
31 #include "huffman.h"
32 #include "internal.h"
33 #include "put_bits.h"
34 #include "libavutil/pixdesc.h"
35
36 static inline int sub_left_prediction(HYuvContext *s, uint8_t *dst,
37                                       const uint8_t *src, int w, int left)
38 {
39     int i;
40     if (w < 32) {
41         for (i = 0; i < w; i++) {
42             const int temp = src[i];
43             dst[i] = temp - left;
44             left   = temp;
45         }
46         return left;
47     } else {
48         for (i = 0; i < 16; i++) {
49             const int temp = src[i];
50             dst[i] = temp - left;
51             left   = temp;
52         }
53         s->dsp.diff_bytes(dst + 16, src + 16, src + 15, w - 16);
54         return src[w-1];
55     }
56 }
57
58 static inline void sub_left_prediction_bgr32(HYuvContext *s, uint8_t *dst,
59                                              const uint8_t *src, int w,
60                                              int *red, int *green, int *blue,
61                                              int *alpha)
62 {
63     int i;
64     int r, g, b, a;
65     r = *red;
66     g = *green;
67     b = *blue;
68     a = *alpha;
69
70     for (i = 0; i < FFMIN(w, 4); i++) {
71         const int rt = src[i * 4 + R];
72         const int gt = src[i * 4 + G];
73         const int bt = src[i * 4 + B];
74         const int at = src[i * 4 + A];
75         dst[i * 4 + R] = rt - r;
76         dst[i * 4 + G] = gt - g;
77         dst[i * 4 + B] = bt - b;
78         dst[i * 4 + A] = at - a;
79         r = rt;
80         g = gt;
81         b = bt;
82         a = at;
83     }
84
85     s->dsp.diff_bytes(dst + 16, src + 16, src + 12, w * 4 - 16);
86
87     *red   = src[(w - 1) * 4 + R];
88     *green = src[(w - 1) * 4 + G];
89     *blue  = src[(w - 1) * 4 + B];
90     *alpha = src[(w - 1) * 4 + A];
91 }
92
93 static inline void sub_left_prediction_rgb24(HYuvContext *s, uint8_t *dst,
94                                              uint8_t *src, int w,
95                                              int *red, int *green, int *blue)
96 {
97     int i;
98     int r, g, b;
99     r = *red;
100     g = *green;
101     b = *blue;
102     for (i = 0; i < FFMIN(w, 16); i++) {
103         const int rt = src[i * 3 + 0];
104         const int gt = src[i * 3 + 1];
105         const int bt = src[i * 3 + 2];
106         dst[i * 3 + 0] = rt - r;
107         dst[i * 3 + 1] = gt - g;
108         dst[i * 3 + 2] = bt - b;
109         r = rt;
110         g = gt;
111         b = bt;
112     }
113
114     s->dsp.diff_bytes(dst + 48, src + 48, src + 48 - 3, w * 3 - 48);
115
116     *red   = src[(w - 1) * 3 + 0];
117     *green = src[(w - 1) * 3 + 1];
118     *blue  = src[(w - 1) * 3 + 2];
119 }
120
121 static int store_table(HYuvContext *s, const uint8_t *len, uint8_t *buf)
122 {
123     int i;
124     int index = 0;
125
126     for (i = 0; i < 256;) {
127         int val = len[i];
128         int repeat = 0;
129
130         for (; i < 256 && len[i] == val && repeat < 255; i++)
131             repeat++;
132
133         av_assert0(val < 32 && val >0 && repeat<256 && repeat>0);
134         if (repeat > 7) {
135             buf[index++] = val;
136             buf[index++] = repeat;
137         } else {
138             buf[index++] = val | (repeat << 5);
139         }
140     }
141
142     return index;
143 }
144
145 static av_cold int encode_init(AVCodecContext *avctx)
146 {
147     HYuvContext *s = avctx->priv_data;
148     int i, j;
149     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(avctx->pix_fmt);
150     int extradata_tables;
151
152     ff_huffyuv_common_init(avctx);
153
154     avctx->extradata = av_mallocz(1024*30); // 256*3+4 == 772
155     avctx->stats_out = av_mallocz(1024*30); // 21*256*3(%llu ) + 3(\n) + 1(0) = 16132
156     if (!avctx->extradata || !avctx->stats_out) {
157         av_freep(&avctx->stats_out);
158         return AVERROR(ENOMEM);
159     }
160     s->version = 2;
161
162     avctx->coded_frame = av_frame_alloc();
163     if (!avctx->coded_frame)
164         return AVERROR(ENOMEM);
165
166     avctx->coded_frame->pict_type = AV_PICTURE_TYPE_I;
167     avctx->coded_frame->key_frame = 1;
168
169     s->bps = 8;
170     s->yuv = !(desc->flags & AV_PIX_FMT_FLAG_RGB) && desc->nb_components >= 2;
171     s->chroma = desc->nb_components > 2;
172     s->alpha = !!(desc->flags & AV_PIX_FMT_FLAG_ALPHA);
173     av_pix_fmt_get_chroma_sub_sample(avctx->pix_fmt,
174                                      &s->chroma_h_shift,
175                                      &s->chroma_v_shift);
176
177     switch (avctx->pix_fmt) {
178     case AV_PIX_FMT_YUV420P:
179     case AV_PIX_FMT_YUV422P:
180         if (s->width & 1) {
181             av_log(avctx, AV_LOG_ERROR, "Width must be even for this colorspace.\n");
182             return AVERROR(EINVAL);
183         }
184         s->bitstream_bpp = avctx->pix_fmt == AV_PIX_FMT_YUV420P ? 12 : 16;
185         break;
186     case AV_PIX_FMT_YUV444P:
187     case AV_PIX_FMT_YUV410P:
188     case AV_PIX_FMT_YUV411P:
189     case AV_PIX_FMT_YUV440P:
190     case AV_PIX_FMT_GBRP:
191     case AV_PIX_FMT_GRAY8:
192     case AV_PIX_FMT_YUVA444P:
193     case AV_PIX_FMT_YUVA420P:
194     case AV_PIX_FMT_YUVA422P:
195     case AV_PIX_FMT_GBRAP:
196     case AV_PIX_FMT_GRAY8A:
197         s->version = 3;
198         break;
199     case AV_PIX_FMT_RGB32:
200         s->bitstream_bpp = 32;
201         break;
202     case AV_PIX_FMT_RGB24:
203         s->bitstream_bpp = 24;
204         break;
205     default:
206         av_log(avctx, AV_LOG_ERROR, "format not supported\n");
207         return AVERROR(EINVAL);
208     }
209
210     avctx->bits_per_coded_sample = s->bitstream_bpp;
211     s->decorrelate = s->bitstream_bpp >= 24 && !s->yuv && avctx->pix_fmt != AV_PIX_FMT_GBRP;
212     s->predictor = avctx->prediction_method;
213     s->interlaced = avctx->flags&CODEC_FLAG_INTERLACED_ME ? 1 : 0;
214     if (avctx->context_model == 1) {
215         s->context = avctx->context_model;
216         if (s->flags & (CODEC_FLAG_PASS1|CODEC_FLAG_PASS2)) {
217             av_log(avctx, AV_LOG_ERROR,
218                    "context=1 is not compatible with "
219                    "2 pass huffyuv encoding\n");
220             return AVERROR(EINVAL);
221         }
222     }else s->context= 0;
223
224     if (avctx->codec->id == AV_CODEC_ID_HUFFYUV) {
225         if (avctx->pix_fmt == AV_PIX_FMT_YUV420P) {
226             av_log(avctx, AV_LOG_ERROR,
227                    "Error: YV12 is not supported by huffyuv; use "
228                    "vcodec=ffvhuff or format=422p\n");
229             return AVERROR(EINVAL);
230         }
231         if (avctx->context_model) {
232             av_log(avctx, AV_LOG_ERROR,
233                    "Error: per-frame huffman tables are not supported "
234                    "by huffyuv; use vcodec=ffvhuff\n");
235             return AVERROR(EINVAL);
236         }
237         if (s->version > 2) {
238             av_log(avctx, AV_LOG_ERROR,
239                    "Error: ver>2 is not supported "
240                    "by huffyuv; use vcodec=ffvhuff\n");
241             return AVERROR(EINVAL);
242         }
243         if (s->interlaced != ( s->height > 288 ))
244             av_log(avctx, AV_LOG_INFO,
245                    "using huffyuv 2.2.0 or newer interlacing flag\n");
246     }
247
248     if (s->version > 2 && avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
249         av_log(avctx, AV_LOG_ERROR, "Ver > 2 is under development, files encoded with it may not be decodable with future versions!!!\n"
250                "Use vstrict=-2 / -strict -2 to use it anyway.\n");
251         return AVERROR(EINVAL);
252     }
253
254     if (s->bitstream_bpp >= 24 && s->predictor == MEDIAN) {
255         av_log(avctx, AV_LOG_ERROR,
256                "Error: RGB is incompatible with median predictor\n");
257         return AVERROR(EINVAL);
258     }
259
260     extradata_tables = 1 + 2*s->chroma + s->alpha;
261     ((uint8_t*)avctx->extradata)[0] = s->predictor | (s->decorrelate << 6);
262     ((uint8_t*)avctx->extradata)[2] = s->interlaced ? 0x10 : 0x20;
263     if (s->context)
264         ((uint8_t*)avctx->extradata)[2] |= 0x40;
265     if (s->version < 3) {
266         ((uint8_t*)avctx->extradata)[1] = s->bitstream_bpp;
267         ((uint8_t*)avctx->extradata)[3] = 0;
268         extradata_tables = 3;
269     } else {
270         ((uint8_t*)avctx->extradata)[1] = ((s->bps-1)<<4) | s->chroma_h_shift | (s->chroma_v_shift<<2);
271         if (s->chroma)
272             ((uint8_t*)avctx->extradata)[2] |= s->yuv ? 1 : 2;
273         if (s->alpha)
274             ((uint8_t*)avctx->extradata)[2] |= 4;
275         ((uint8_t*)avctx->extradata)[3] = 1;
276     }
277     s->avctx->extradata_size = 4;
278
279     if (avctx->stats_in) {
280         char *p = avctx->stats_in;
281
282         for (i = 0; i < 4; i++)
283             for (j = 0; j < 256; j++)
284                 s->stats[i][j] = 1;
285
286         for (;;) {
287             for (i = 0; i < 4; i++) {
288                 char *next;
289
290                 for (j = 0; j < 256; j++) {
291                     s->stats[i][j] += strtol(p, &next, 0);
292                     if (next == p) return -1;
293                     p = next;
294                 }
295             }
296             if (p[0] == 0 || p[1] == 0 || p[2] == 0) break;
297         }
298     } else {
299         for (i = 0; i < 4; i++)
300             for (j = 0; j < 256; j++) {
301                 int d = FFMIN(j, 256 - j);
302
303                 s->stats[i][j] = 100000000 / (d + 1);
304             }
305     }
306
307     for (i = 0; i < extradata_tables; i++) {
308         ff_huff_gen_len_table(s->len[i], s->stats[i]);
309
310         if (ff_huffyuv_generate_bits_table(s->bits[i], s->len[i]) < 0) {
311             return -1;
312         }
313
314         s->avctx->extradata_size +=
315             store_table(s, s->len[i], &((uint8_t*)s->avctx->extradata)[s->avctx->extradata_size]);
316     }
317
318     if (s->context) {
319         for (i = 0; i < 4; i++) {
320             int pels = s->width * s->height / (i ? 40 : 10);
321             for (j = 0; j < 256; j++) {
322                 int d = FFMIN(j, 256 - j);
323                 s->stats[i][j] = pels/(d + 1);
324             }
325         }
326     } else {
327         for (i = 0; i < 4; i++)
328             for (j = 0; j < 256; j++)
329                 s->stats[i][j]= 0;
330     }
331
332     if (ff_huffyuv_alloc_temp(s)) {
333         ff_huffyuv_common_end(s);
334         return AVERROR(ENOMEM);
335     }
336
337     s->picture_number=0;
338
339     return 0;
340 }
341 static int encode_422_bitstream(HYuvContext *s, int offset, int count)
342 {
343     int i;
344     const uint8_t *y = s->temp[0] + offset;
345     const uint8_t *u = s->temp[1] + offset / 2;
346     const uint8_t *v = s->temp[2] + offset / 2;
347
348     if (s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb) >> 3) < 2 * 4 * count) {
349         av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
350         return -1;
351     }
352
353 #define LOAD4\
354             int y0 = y[2 * i];\
355             int y1 = y[2 * i + 1];\
356             int u0 = u[i];\
357             int v0 = v[i];
358
359     count /= 2;
360
361     if (s->flags & CODEC_FLAG_PASS1) {
362         for(i = 0; i < count; i++) {
363             LOAD4;
364             s->stats[0][y0]++;
365             s->stats[1][u0]++;
366             s->stats[0][y1]++;
367             s->stats[2][v0]++;
368         }
369     }
370     if (s->avctx->flags2 & CODEC_FLAG2_NO_OUTPUT)
371         return 0;
372     if (s->context) {
373         for (i = 0; i < count; i++) {
374             LOAD4;
375             s->stats[0][y0]++;
376             put_bits(&s->pb, s->len[0][y0], s->bits[0][y0]);
377             s->stats[1][u0]++;
378             put_bits(&s->pb, s->len[1][u0], s->bits[1][u0]);
379             s->stats[0][y1]++;
380             put_bits(&s->pb, s->len[0][y1], s->bits[0][y1]);
381             s->stats[2][v0]++;
382             put_bits(&s->pb, s->len[2][v0], s->bits[2][v0]);
383         }
384     } else {
385         for(i = 0; i < count; i++) {
386             LOAD4;
387             put_bits(&s->pb, s->len[0][y0], s->bits[0][y0]);
388             put_bits(&s->pb, s->len[1][u0], s->bits[1][u0]);
389             put_bits(&s->pb, s->len[0][y1], s->bits[0][y1]);
390             put_bits(&s->pb, s->len[2][v0], s->bits[2][v0]);
391         }
392     }
393     return 0;
394 }
395
396 static int encode_plane_bitstream(HYuvContext *s, int count, int plane)
397 {
398     int i;
399
400     if (s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb) >> 3) < 4 * count) {
401         av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
402         return -1;
403     }
404
405 #define LOAD2\
406             int y0 = s->temp[0][2 * i];\
407             int y1 = s->temp[0][2 * i + 1];
408 #define STAT2\
409             s->stats[plane][y0]++;\
410             s->stats[plane][y1]++;
411 #define WRITE2\
412             put_bits(&s->pb, s->len[plane][y0], s->bits[plane][y0]);\
413             put_bits(&s->pb, s->len[plane][y1], s->bits[plane][y1]);
414
415     count /= 2;
416
417     if (s->flags & CODEC_FLAG_PASS1) {
418         for (i = 0; i < count; i++) {
419             LOAD2;
420             STAT2;
421         }
422     }
423     if (s->avctx->flags2 & CODEC_FLAG2_NO_OUTPUT)
424         return 0;
425
426     if (s->context) {
427         for (i = 0; i < count; i++) {
428             LOAD2;
429             STAT2;
430             WRITE2;
431         }
432     } else {
433         for (i = 0; i < count; i++) {
434             LOAD2;
435             WRITE2;
436         }
437     }
438 #undef LOAD2
439 #undef STAT2
440 #undef WRITE2
441     return 0;
442 }
443
444 static int encode_gray_bitstream(HYuvContext *s, int count)
445 {
446     int i;
447
448     if (s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb) >> 3) < 4 * count) {
449         av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
450         return -1;
451     }
452
453 #define LOAD2\
454             int y0 = s->temp[0][2 * i];\
455             int y1 = s->temp[0][2 * i + 1];
456 #define STAT2\
457             s->stats[0][y0]++;\
458             s->stats[0][y1]++;
459 #define WRITE2\
460             put_bits(&s->pb, s->len[0][y0], s->bits[0][y0]);\
461             put_bits(&s->pb, s->len[0][y1], s->bits[0][y1]);
462
463     count /= 2;
464
465     if (s->flags & CODEC_FLAG_PASS1) {
466         for (i = 0; i < count; i++) {
467             LOAD2;
468             STAT2;
469         }
470     }
471     if (s->avctx->flags2 & CODEC_FLAG2_NO_OUTPUT)
472         return 0;
473
474     if (s->context) {
475         for (i = 0; i < count; i++) {
476             LOAD2;
477             STAT2;
478             WRITE2;
479         }
480     } else {
481         for (i = 0; i < count; i++) {
482             LOAD2;
483             WRITE2;
484         }
485     }
486     return 0;
487 }
488
489 static inline int encode_bgra_bitstream(HYuvContext *s, int count, int planes)
490 {
491     int i;
492
493     if (s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb) >> 3) <
494         4 * planes * count) {
495         av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
496         return -1;
497     }
498
499 #define LOAD_GBRA                                                       \
500     int g = s->temp[0][planes == 3 ? 3 * i + 1 : 4 * i + G];            \
501     int b =(s->temp[0][planes == 3 ? 3 * i + 2 : 4 * i + B] - g) & 0xFF;\
502     int r =(s->temp[0][planes == 3 ? 3 * i + 0 : 4 * i + R] - g) & 0xFF;\
503     int a = s->temp[0][planes * i + A];
504
505 #define STAT_BGRA                                                       \
506     s->stats[0][b]++;                                                   \
507     s->stats[1][g]++;                                                   \
508     s->stats[2][r]++;                                                   \
509     if (planes == 4)                                                    \
510         s->stats[2][a]++;
511
512 #define WRITE_GBRA                                                      \
513     put_bits(&s->pb, s->len[1][g], s->bits[1][g]);                      \
514     put_bits(&s->pb, s->len[0][b], s->bits[0][b]);                      \
515     put_bits(&s->pb, s->len[2][r], s->bits[2][r]);                      \
516     if (planes == 4)                                                    \
517         put_bits(&s->pb, s->len[2][a], s->bits[2][a]);
518
519     if ((s->flags & CODEC_FLAG_PASS1) &&
520         (s->avctx->flags2 & CODEC_FLAG2_NO_OUTPUT)) {
521         for (i = 0; i < count; i++) {
522             LOAD_GBRA;
523             STAT_BGRA;
524         }
525     } else if (s->context || (s->flags & CODEC_FLAG_PASS1)) {
526         for (i = 0; i < count; i++) {
527             LOAD_GBRA;
528             STAT_BGRA;
529             WRITE_GBRA;
530         }
531     } else {
532         for (i = 0; i < count; i++) {
533             LOAD_GBRA;
534             WRITE_GBRA;
535         }
536     }
537     return 0;
538 }
539
540 static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
541                         const AVFrame *pict, int *got_packet)
542 {
543     HYuvContext *s = avctx->priv_data;
544     const int width = s->width;
545     const int width2 = s->width>>1;
546     const int height = s->height;
547     const int fake_ystride = s->interlaced ? pict->linesize[0]*2  : pict->linesize[0];
548     const int fake_ustride = s->interlaced ? pict->linesize[1]*2  : pict->linesize[1];
549     const int fake_vstride = s->interlaced ? pict->linesize[2]*2  : pict->linesize[2];
550     const AVFrame * const p = pict;
551     int i, j, size = 0, ret;
552
553     if ((ret = ff_alloc_packet2(avctx, pkt, width * height * 3 * 4 + FF_MIN_BUFFER_SIZE)) < 0)
554         return ret;
555
556     if (s->context) {
557         for (i = 0; i < 4; i++) {
558             ff_huff_gen_len_table(s->len[i], s->stats[i]);
559             if (ff_huffyuv_generate_bits_table(s->bits[i], s->len[i]) < 0)
560                 return -1;
561             size += store_table(s, s->len[i], &pkt->data[size]);
562         }
563
564         for (i = 0; i < 4; i++)
565             for (j = 0; j < 256; j++)
566                 s->stats[i][j] >>= 1;
567     }
568
569     init_put_bits(&s->pb, pkt->data + size, pkt->size - size);
570
571     if (avctx->pix_fmt == AV_PIX_FMT_YUV422P ||
572         avctx->pix_fmt == AV_PIX_FMT_YUV420P) {
573         int lefty, leftu, leftv, y, cy;
574
575         put_bits(&s->pb, 8, leftv = p->data[2][0]);
576         put_bits(&s->pb, 8, lefty = p->data[0][1]);
577         put_bits(&s->pb, 8, leftu = p->data[1][0]);
578         put_bits(&s->pb, 8,         p->data[0][0]);
579
580         lefty = sub_left_prediction(s, s->temp[0], p->data[0], width , 0);
581         leftu = sub_left_prediction(s, s->temp[1], p->data[1], width2, 0);
582         leftv = sub_left_prediction(s, s->temp[2], p->data[2], width2, 0);
583
584         encode_422_bitstream(s, 2, width-2);
585
586         if (s->predictor==MEDIAN) {
587             int lefttopy, lefttopu, lefttopv;
588             cy = y = 1;
589             if (s->interlaced) {
590                 lefty = sub_left_prediction(s, s->temp[0], p->data[0] + p->linesize[0], width , lefty);
591                 leftu = sub_left_prediction(s, s->temp[1], p->data[1] + p->linesize[1], width2, leftu);
592                 leftv = sub_left_prediction(s, s->temp[2], p->data[2] + p->linesize[2], width2, leftv);
593
594                 encode_422_bitstream(s, 0, width);
595                 y++; cy++;
596             }
597
598             lefty = sub_left_prediction(s, s->temp[0], p->data[0] + fake_ystride, 4, lefty);
599             leftu = sub_left_prediction(s, s->temp[1], p->data[1] + fake_ustride, 2, leftu);
600             leftv = sub_left_prediction(s, s->temp[2], p->data[2] + fake_vstride, 2, leftv);
601
602             encode_422_bitstream(s, 0, 4);
603
604             lefttopy = p->data[0][3];
605             lefttopu = p->data[1][1];
606             lefttopv = p->data[2][1];
607             s->dsp.sub_hfyu_median_prediction(s->temp[0], p->data[0]+4, p->data[0] + fake_ystride + 4, width - 4 , &lefty, &lefttopy);
608             s->dsp.sub_hfyu_median_prediction(s->temp[1], p->data[1]+2, p->data[1] + fake_ustride + 2, width2 - 2, &leftu, &lefttopu);
609             s->dsp.sub_hfyu_median_prediction(s->temp[2], p->data[2]+2, p->data[2] + fake_vstride + 2, width2 - 2, &leftv, &lefttopv);
610             encode_422_bitstream(s, 0, width - 4);
611             y++; cy++;
612
613             for (; y < height; y++,cy++) {
614                 uint8_t *ydst, *udst, *vdst;
615
616                 if (s->bitstream_bpp == 12) {
617                     while (2 * cy > y) {
618                         ydst = p->data[0] + p->linesize[0] * y;
619                         s->dsp.sub_hfyu_median_prediction(s->temp[0], ydst - fake_ystride, ydst, width , &lefty, &lefttopy);
620                         encode_gray_bitstream(s, width);
621                         y++;
622                     }
623                     if (y >= height) break;
624                 }
625                 ydst = p->data[0] + p->linesize[0] * y;
626                 udst = p->data[1] + p->linesize[1] * cy;
627                 vdst = p->data[2] + p->linesize[2] * cy;
628
629                 s->dsp.sub_hfyu_median_prediction(s->temp[0], ydst - fake_ystride, ydst, width , &lefty, &lefttopy);
630                 s->dsp.sub_hfyu_median_prediction(s->temp[1], udst - fake_ustride, udst, width2, &leftu, &lefttopu);
631                 s->dsp.sub_hfyu_median_prediction(s->temp[2], vdst - fake_vstride, vdst, width2, &leftv, &lefttopv);
632
633                 encode_422_bitstream(s, 0, width);
634             }
635         } else {
636             for (cy = y = 1; y < height; y++, cy++) {
637                 uint8_t *ydst, *udst, *vdst;
638
639                 /* encode a luma only line & y++ */
640                 if (s->bitstream_bpp == 12) {
641                     ydst = p->data[0] + p->linesize[0] * y;
642
643                     if (s->predictor == PLANE && s->interlaced < y) {
644                         s->dsp.diff_bytes(s->temp[1], ydst, ydst - fake_ystride, width);
645
646                         lefty = sub_left_prediction(s, s->temp[0], s->temp[1], width , lefty);
647                     } else {
648                         lefty = sub_left_prediction(s, s->temp[0], ydst, width , lefty);
649                     }
650                     encode_gray_bitstream(s, width);
651                     y++;
652                     if (y >= height) break;
653                 }
654
655                 ydst = p->data[0] + p->linesize[0] * y;
656                 udst = p->data[1] + p->linesize[1] * cy;
657                 vdst = p->data[2] + p->linesize[2] * cy;
658
659                 if (s->predictor == PLANE && s->interlaced < cy) {
660                     s->dsp.diff_bytes(s->temp[1], ydst, ydst - fake_ystride, width);
661                     s->dsp.diff_bytes(s->temp[2], udst, udst - fake_ustride, width2);
662                     s->dsp.diff_bytes(s->temp[2] + width2, vdst, vdst - fake_vstride, width2);
663
664                     lefty = sub_left_prediction(s, s->temp[0], s->temp[1], width , lefty);
665                     leftu = sub_left_prediction(s, s->temp[1], s->temp[2], width2, leftu);
666                     leftv = sub_left_prediction(s, s->temp[2], s->temp[2] + width2, width2, leftv);
667                 } else {
668                     lefty = sub_left_prediction(s, s->temp[0], ydst, width , lefty);
669                     leftu = sub_left_prediction(s, s->temp[1], udst, width2, leftu);
670                     leftv = sub_left_prediction(s, s->temp[2], vdst, width2, leftv);
671                 }
672
673                 encode_422_bitstream(s, 0, width);
674             }
675         }
676     } else if(avctx->pix_fmt == AV_PIX_FMT_RGB32) {
677         uint8_t *data = p->data[0] + (height - 1) * p->linesize[0];
678         const int stride = -p->linesize[0];
679         const int fake_stride = -fake_ystride;
680         int y;
681         int leftr, leftg, leftb, lefta;
682
683         put_bits(&s->pb, 8, lefta = data[A]);
684         put_bits(&s->pb, 8, leftr = data[R]);
685         put_bits(&s->pb, 8, leftg = data[G]);
686         put_bits(&s->pb, 8, leftb = data[B]);
687
688         sub_left_prediction_bgr32(s, s->temp[0], data + 4, width - 1,
689                                   &leftr, &leftg, &leftb, &lefta);
690         encode_bgra_bitstream(s, width - 1, 4);
691
692         for (y = 1; y < s->height; y++) {
693             uint8_t *dst = data + y*stride;
694             if (s->predictor == PLANE && s->interlaced < y) {
695                 s->dsp.diff_bytes(s->temp[1], dst, dst - fake_stride, width * 4);
696                 sub_left_prediction_bgr32(s, s->temp[0], s->temp[1], width,
697                                           &leftr, &leftg, &leftb, &lefta);
698             } else {
699                 sub_left_prediction_bgr32(s, s->temp[0], dst, width,
700                                           &leftr, &leftg, &leftb, &lefta);
701             }
702             encode_bgra_bitstream(s, width, 4);
703         }
704     } else if (avctx->pix_fmt == AV_PIX_FMT_RGB24) {
705         uint8_t *data = p->data[0] + (height - 1) * p->linesize[0];
706         const int stride = -p->linesize[0];
707         const int fake_stride = -fake_ystride;
708         int y;
709         int leftr, leftg, leftb;
710
711         put_bits(&s->pb, 8, leftr = data[0]);
712         put_bits(&s->pb, 8, leftg = data[1]);
713         put_bits(&s->pb, 8, leftb = data[2]);
714         put_bits(&s->pb, 8, 0);
715
716         sub_left_prediction_rgb24(s, s->temp[0], data + 3, width - 1,
717                                   &leftr, &leftg, &leftb);
718         encode_bgra_bitstream(s, width-1, 3);
719
720         for (y = 1; y < s->height; y++) {
721             uint8_t *dst = data + y * stride;
722             if (s->predictor == PLANE && s->interlaced < y) {
723                 s->dsp.diff_bytes(s->temp[1], dst, dst - fake_stride,
724                                   width * 3);
725                 sub_left_prediction_rgb24(s, s->temp[0], s->temp[1], width,
726                                           &leftr, &leftg, &leftb);
727             } else {
728                 sub_left_prediction_rgb24(s, s->temp[0], dst, width,
729                                           &leftr, &leftg, &leftb);
730             }
731             encode_bgra_bitstream(s, width, 3);
732         }
733     } else if (s->version > 2) {
734         int plane;
735         for (plane = 0; plane < 1 + 2*s->chroma + s->alpha; plane++) {
736             int left, y;
737             int w = width;
738             int h = height;
739             int fake_stride = fake_ystride;
740
741             if (s->chroma && (plane == 1 || plane == 2)) {
742                 w >>= s->chroma_h_shift;
743                 h >>= s->chroma_v_shift;
744                 fake_stride = plane == 1 ? fake_ustride : fake_vstride;
745             }
746
747             left = sub_left_prediction(s, s->temp[0], p->data[plane], w , 0);
748
749             encode_plane_bitstream(s, w, plane);
750
751             if (s->predictor==MEDIAN) {
752                 int lefttop;
753                 y = 1;
754                 if (s->interlaced) {
755                     left = sub_left_prediction(s, s->temp[0], p->data[plane] + p->linesize[plane], w , left);
756
757                     encode_plane_bitstream(s, w, plane);
758                     y++;
759                 }
760
761                 lefttop = p->data[plane][0];
762
763                 for (; y < h; y++) {
764                     uint8_t *dst = p->data[plane] + p->linesize[plane] * y;
765
766                     s->dsp.sub_hfyu_median_prediction(s->temp[0], dst - fake_stride, dst, w , &left, &lefttop);
767
768                     encode_plane_bitstream(s, w, plane);
769                 }
770             } else {
771                 for (y = 1; y < h; y++) {
772                     uint8_t *dst = p->data[plane] + p->linesize[plane] * y;
773
774                     if (s->predictor == PLANE && s->interlaced < y) {
775                         s->dsp.diff_bytes(s->temp[1], dst, dst - fake_stride, w);
776
777                         left = sub_left_prediction(s, s->temp[0], s->temp[1], w , left);
778                     } else {
779                         left = sub_left_prediction(s, s->temp[0], dst, w , left);
780                     }
781
782                     encode_plane_bitstream(s, w, plane);
783                 }
784             }
785         }
786     } else {
787         av_log(avctx, AV_LOG_ERROR, "Format not supported!\n");
788     }
789     emms_c();
790
791     size += (put_bits_count(&s->pb) + 31) / 8;
792     put_bits(&s->pb, 16, 0);
793     put_bits(&s->pb, 15, 0);
794     size /= 4;
795
796     if ((s->flags&CODEC_FLAG_PASS1) && (s->picture_number & 31) == 0) {
797         int j;
798         char *p = avctx->stats_out;
799         char *end = p + 1024*30;
800         for (i = 0; i < 4; i++) {
801             for (j = 0; j < 256; j++) {
802                 snprintf(p, end-p, "%"PRIu64" ", s->stats[i][j]);
803                 p += strlen(p);
804                 s->stats[i][j]= 0;
805             }
806             snprintf(p, end-p, "\n");
807             p++;
808         }
809     } else
810         avctx->stats_out[0] = '\0';
811     if (!(s->avctx->flags2 & CODEC_FLAG2_NO_OUTPUT)) {
812         flush_put_bits(&s->pb);
813         s->dsp.bswap_buf((uint32_t*)pkt->data, (uint32_t*)pkt->data, size);
814     }
815
816     s->picture_number++;
817
818     pkt->size   = size * 4;
819     pkt->flags |= AV_PKT_FLAG_KEY;
820     *got_packet = 1;
821
822     return 0;
823 }
824
825 static av_cold int encode_end(AVCodecContext *avctx)
826 {
827     HYuvContext *s = avctx->priv_data;
828
829     ff_huffyuv_common_end(s);
830
831     av_freep(&avctx->extradata);
832     av_freep(&avctx->stats_out);
833
834     av_frame_free(&avctx->coded_frame);
835
836     return 0;
837 }
838
839 #if CONFIG_HUFFYUV_ENCODER
840 AVCodec ff_huffyuv_encoder = {
841     .name           = "huffyuv",
842     .long_name      = NULL_IF_CONFIG_SMALL("Huffyuv / HuffYUV"),
843     .type           = AVMEDIA_TYPE_VIDEO,
844     .id             = AV_CODEC_ID_HUFFYUV,
845     .priv_data_size = sizeof(HYuvContext),
846     .init           = encode_init,
847     .encode2        = encode_frame,
848     .close          = encode_end,
849     .pix_fmts       = (const enum AVPixelFormat[]){
850         AV_PIX_FMT_YUV422P, AV_PIX_FMT_RGB24,
851         AV_PIX_FMT_RGB32, AV_PIX_FMT_NONE
852     },
853 };
854 #endif
855
856 #if CONFIG_FFVHUFF_ENCODER
857 AVCodec ff_ffvhuff_encoder = {
858     .name           = "ffvhuff",
859     .long_name      = NULL_IF_CONFIG_SMALL("Huffyuv FFmpeg variant"),
860     .type           = AVMEDIA_TYPE_VIDEO,
861     .id             = AV_CODEC_ID_FFVHUFF,
862     .priv_data_size = sizeof(HYuvContext),
863     .init           = encode_init,
864     .encode2        = encode_frame,
865     .close          = encode_end,
866     .pix_fmts       = (const enum AVPixelFormat[]){
867         AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUV411P,
868         AV_PIX_FMT_YUV410P, AV_PIX_FMT_YUV440P,
869         AV_PIX_FMT_GBRP,
870         AV_PIX_FMT_GRAY8,
871         AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUVA444P,
872         AV_PIX_FMT_GBRAP,
873         AV_PIX_FMT_GRAY8A,
874         AV_PIX_FMT_RGB24,
875         AV_PIX_FMT_RGB32, AV_PIX_FMT_NONE
876     },
877 };
878 #endif