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