Make sure the last bits of huffyuv frames are zeroed.
[libav.git] / libavcodec / huffyuv.c
CommitLineData
11f18faf
MN
1/*
2 * huffyuv codec for libavcodec
3 *
aaa1e4cd 4 * Copyright (c) 2002-2003 Michael Niedermayer <michaelni@gmx.at>
11f18faf 5 *
7b94177e
DB
6 * see http://www.pcisys.net/~melanson/codecs/huffyuv.txt for a description of
7 * the algorithm used
8 *
b78e7197
DB
9 * This file is part of FFmpeg.
10 *
11 * FFmpeg is free software; you can redistribute it and/or
11f18faf
MN
12 * modify it under the terms of the GNU Lesser General Public
13 * License as published by the Free Software Foundation; either
b78e7197 14 * version 2.1 of the License, or (at your option) any later version.
11f18faf 15 *
b78e7197 16 * FFmpeg is distributed in the hope that it will be useful,
11f18faf
MN
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19 * Lesser General Public License for more details.
20 *
21 * You should have received a copy of the GNU Lesser General Public
b78e7197 22 * License along with FFmpeg; if not, write to the Free Software
5509bffa 23 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
11f18faf 24 */
115329f1 25
983e3246 26/**
bad5537e 27 * @file libavcodec/huffyuv.c
983e3246
MN
28 * huffyuv codec for libavcodec.
29 */
11f18faf 30
11f18faf 31#include "avcodec.h"
2029f312 32#include "bitstream.h"
11f18faf
MN
33#include "dsputil.h"
34
11f18faf 35#define VLC_BITS 11
1e491e29 36
3ad7dd8c
MN
37#ifdef WORDS_BIGENDIAN
38#define B 3
39#define G 2
40#define R 1
41#else
42#define B 0
43#define G 1
44#define R 2
45#endif
46
11f18faf
MN
47typedef enum Predictor{
48 LEFT= 0,
49 PLANE,
50 MEDIAN,
51} Predictor;
115329f1 52
11f18faf
MN
53typedef struct HYuvContext{
54 AVCodecContext *avctx;
55 Predictor predictor;
56 GetBitContext gb;
57 PutBitContext pb;
58 int interlaced;
59 int decorrelate;
60 int bitstream_bpp;
61 int version;
62 int yuy2; //use yuy2 instead of 422P
63 int bgr32; //use bgr32 instead of bgr24
64 int width, height;
65 int flags;
11087086 66 int context;
11f18faf 67 int picture_number;
7c5ab7b8 68 int last_slice_end;
0ecca7a4 69 uint8_t *temp[3];
11f18faf
MN
70 uint64_t stats[3][256];
71 uint8_t len[3][256];
72 uint32_t bits[3][256];
8be6dac8 73 uint32_t pix_bgr_map[1<<VLC_BITS];
19716d64 74 VLC vlc[6]; //Y,U,V,YY,YU,YV
492cd3a9 75 AVFrame picture;
0ecca7a4 76 uint8_t *bitstream_buffer;
f038fe8b 77 unsigned int bitstream_buffer_size;
115329f1 78 DSPContext dsp;
11f18faf
MN
79}HYuvContext;
80
24def10e 81static const unsigned char classic_shift_luma[] = {
676b385c
MN
82 34,36,35,69,135,232,9,16,10,24,11,23,12,16,13,10,14,8,15,8,
83 16,8,17,20,16,10,207,206,205,236,11,8,10,21,9,23,8,8,199,70,
84 69,68, 0
85};
86
24def10e 87static const unsigned char classic_shift_chroma[] = {
676b385c
MN
88 66,36,37,38,39,40,41,75,76,77,110,239,144,81,82,83,84,85,118,183,
89 56,57,88,89,56,89,154,57,58,57,26,141,57,56,58,57,58,57,184,119,
90 214,245,116,83,82,49,80,79,78,77,44,75,41,40,39,38,37,36,34, 0
91};
92
24def10e 93static const unsigned char classic_add_luma[256] = {
676b385c
MN
94 3, 9, 5, 12, 10, 35, 32, 29, 27, 50, 48, 45, 44, 41, 39, 37,
95 73, 70, 68, 65, 64, 61, 58, 56, 53, 50, 49, 46, 44, 41, 38, 36,
96 68, 65, 63, 61, 58, 55, 53, 51, 48, 46, 45, 43, 41, 39, 38, 36,
97 35, 33, 32, 30, 29, 27, 26, 25, 48, 47, 46, 44, 43, 41, 40, 39,
98 37, 36, 35, 34, 32, 31, 30, 28, 27, 26, 24, 23, 22, 20, 19, 37,
99 35, 34, 33, 31, 30, 29, 27, 26, 24, 23, 21, 20, 18, 17, 15, 29,
100 27, 26, 24, 22, 21, 19, 17, 16, 14, 26, 25, 23, 21, 19, 18, 16,
101 15, 27, 25, 23, 21, 19, 17, 16, 14, 26, 25, 23, 21, 18, 17, 14,
102 12, 17, 19, 13, 4, 9, 2, 11, 1, 7, 8, 0, 16, 3, 14, 6,
103 12, 10, 5, 15, 18, 11, 10, 13, 15, 16, 19, 20, 22, 24, 27, 15,
104 18, 20, 22, 24, 26, 14, 17, 20, 22, 24, 27, 15, 18, 20, 23, 25,
105 28, 16, 19, 22, 25, 28, 32, 36, 21, 25, 29, 33, 38, 42, 45, 49,
106 28, 31, 34, 37, 40, 42, 44, 47, 49, 50, 52, 54, 56, 57, 59, 60,
107 62, 64, 66, 67, 69, 35, 37, 39, 40, 42, 43, 45, 47, 48, 51, 52,
108 54, 55, 57, 59, 60, 62, 63, 66, 67, 69, 71, 72, 38, 40, 42, 43,
109 46, 47, 49, 51, 26, 28, 30, 31, 33, 34, 18, 19, 11, 13, 7, 8,
110};
111
24def10e 112static const unsigned char classic_add_chroma[256] = {
676b385c
MN
113 3, 1, 2, 2, 2, 2, 3, 3, 7, 5, 7, 5, 8, 6, 11, 9,
114 7, 13, 11, 10, 9, 8, 7, 5, 9, 7, 6, 4, 7, 5, 8, 7,
115 11, 8, 13, 11, 19, 15, 22, 23, 20, 33, 32, 28, 27, 29, 51, 77,
116 43, 45, 76, 81, 46, 82, 75, 55, 56,144, 58, 80, 60, 74,147, 63,
117 143, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
118 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 27, 30, 21, 22,
119 17, 14, 5, 6,100, 54, 47, 50, 51, 53,106,107,108,109,110,111,
120 112,113,114,115, 4,117,118, 92, 94,121,122, 3,124,103, 2, 1,
121 0,129,130,131,120,119,126,125,136,137,138,139,140,141,142,134,
122 135,132,133,104, 64,101, 62, 57,102, 95, 93, 59, 61, 28, 97, 96,
123 52, 49, 48, 29, 32, 25, 24, 46, 23, 98, 45, 44, 43, 20, 42, 41,
124 19, 18, 99, 40, 15, 39, 38, 16, 13, 12, 11, 37, 10, 9, 8, 36,
125 7,128,127,105,123,116, 35, 34, 33,145, 31, 79, 42,146, 78, 26,
126 83, 48, 49, 50, 44, 47, 26, 31, 30, 18, 17, 19, 21, 24, 25, 13,
127 14, 16, 17, 18, 20, 21, 12, 14, 15, 9, 10, 6, 9, 6, 5, 8,
128 6, 12, 8, 10, 7, 9, 6, 4, 6, 2, 2, 3, 3, 3, 3, 2,
129};
130
11f18faf
MN
131static inline int add_left_prediction(uint8_t *dst, uint8_t *src, int w, int acc){
132 int i;
133
134 for(i=0; i<w-1; i++){
135 acc+= src[i];
136 dst[i]= acc;
137 i++;
138 acc+= src[i];
139 dst[i]= acc;
140 }
141
142 for(; i<w; i++){
143 acc+= src[i];
144 dst[i]= acc;
145 }
146
147 return acc;
148}
149
11f18faf
MN
150static inline void add_left_prediction_bgr32(uint8_t *dst, uint8_t *src, int w, int *red, int *green, int *blue){
151 int i;
152 int r,g,b;
153 r= *red;
154 g= *green;
155 b= *blue;
156
157 for(i=0; i<w; i++){
3ad7dd8c
MN
158 b+= src[4*i+B];
159 g+= src[4*i+G];
160 r+= src[4*i+R];
115329f1 161
3ad7dd8c
MN
162 dst[4*i+B]= b;
163 dst[4*i+G]= g;
164 dst[4*i+R]= r;
11f18faf
MN
165 }
166
167 *red= r;
168 *green= g;
169 *blue= b;
170}
171
7c5ab7b8 172static inline int sub_left_prediction(HYuvContext *s, uint8_t *dst, uint8_t *src, int w, int left){
11f18faf 173 int i;
7c5ab7b8
MN
174 if(w<32){
175 for(i=0; i<w; i++){
176 const int temp= src[i];
177 dst[i]= temp - left;
178 left= temp;
179 }
180 return left;
181 }else{
182 for(i=0; i<16; i++){
183 const int temp= src[i];
184 dst[i]= temp - left;
185 left= temp;
186 }
187 s->dsp.diff_bytes(dst+16, src+16, src+15, w-16);
188 return src[w-1];
11f18faf 189 }
11f18faf 190}
2a250222 191
d2bfaf8a
LM
192static inline void sub_left_prediction_bgr32(HYuvContext *s, uint8_t *dst, uint8_t *src, int w, int *red, int *green, int *blue){
193 int i;
194 int r,g,b;
195 r= *red;
196 g= *green;
197 b= *blue;
198 for(i=0; i<FFMIN(w,4); i++){
199 const int rt= src[i*4+R];
200 const int gt= src[i*4+G];
201 const int bt= src[i*4+B];
202 dst[i*4+R]= rt - r;
203 dst[i*4+G]= gt - g;
204 dst[i*4+B]= bt - b;
205 r = rt;
206 g = gt;
207 b = bt;
208 }
209 s->dsp.diff_bytes(dst+16, src+16, src+12, w*4-16);
210 *red= src[(w-1)*4+R];
211 *green= src[(w-1)*4+G];
212 *blue= src[(w-1)*4+B];
213}
214
11f18faf
MN
215static void read_len_table(uint8_t *dst, GetBitContext *gb){
216 int i, val, repeat;
115329f1 217
11f18faf
MN
218 for(i=0; i<256;){
219 repeat= get_bits(gb, 3);
220 val = get_bits(gb, 5);
221 if(repeat==0)
222 repeat= get_bits(gb, 8);
223//printf("%d %d\n", val, repeat);
224 while (repeat--)
225 dst[i++] = val;
226 }
227}
228
229static int generate_bits_table(uint32_t *dst, uint8_t *len_table){
230 int len, index;
231 uint32_t bits=0;
232
233 for(len=32; len>0; len--){
11f18faf 234 for(index=0; index<256; index++){
14b74d38
MN
235 if(len_table[index]==len)
236 dst[index]= bits++;
11f18faf 237 }
14b74d38 238 if(bits & 1){
9b879566 239 av_log(NULL, AV_LOG_ERROR, "Error generating huffman table\n");
14b74d38
MN
240 return -1;
241 }
242 bits >>= 1;
11f18faf
MN
243 }
244 return 0;
245}
246
b250f9c6 247#if CONFIG_HUFFYUV_ENCODER || CONFIG_FFVHUFF_ENCODER
98ef8c32
LM
248typedef struct {
249 uint64_t val;
250 int name;
fe5c7e58 251} HeapElem;
98ef8c32 252
fe5c7e58 253static void heap_sift(HeapElem *h, int root, int size)
98ef8c32
LM
254{
255 while(root*2+1 < size) {
256 int child = root*2+1;
257 if(child < size-1 && h[child].val > h[child+1].val)
258 child++;
259 if(h[root].val > h[child].val) {
fe5c7e58 260 FFSWAP(HeapElem, h[root], h[child]);
98ef8c32
LM
261 root = child;
262 } else
263 break;
264 }
265}
266
11f18faf 267static void generate_len_table(uint8_t *dst, uint64_t *stats, int size){
fe5c7e58 268 HeapElem h[size];
11f18faf 269 int up[2*size];
98ef8c32 270 int len[2*size];
11f18faf 271 int offset, i, next;
115329f1 272
11f18faf
MN
273 for(offset=1; ; offset<<=1){
274 for(i=0; i<size; i++){
98ef8c32
LM
275 h[i].name = i;
276 h[i].val = (stats[i] << 8) + offset;
11f18faf 277 }
98ef8c32
LM
278 for(i=size/2-1; i>=0; i--)
279 heap_sift(h, i, size);
280
281 for(next=size; next<size*2-1; next++){
282 // merge the two smallest entries, and put it back in the heap
283 uint64_t min1v = h[0].val;
284 up[h[0].name] = next;
285 h[0].val = INT64_MAX;
286 heap_sift(h, 0, size);
287 up[h[0].name] = next;
288 h[0].name = next;
289 h[0].val += min1v;
290 heap_sift(h, 0, size);
11f18faf 291 }
115329f1 292
98ef8c32
LM
293 len[2*size-2] = 0;
294 for(i=2*size-3; i>=size; i--)
295 len[i] = len[up[i]] + 1;
296 for(i=0; i<size; i++) {
297 dst[i] = len[up[i]] + 1;
2bf4aa2e 298 if(dst[i] >= 32) break;
11f18faf
MN
299 }
300 if(i==size) break;
301 }
302}
b250f9c6 303#endif /* CONFIG_HUFFYUV_ENCODER || CONFIG_FFVHUFF_ENCODER */
11f18faf 304
19716d64 305static void generate_joint_tables(HYuvContext *s){
8be6dac8
LM
306 uint16_t symbols[1<<VLC_BITS];
307 uint16_t bits[1<<VLC_BITS];
308 uint8_t len[1<<VLC_BITS];
19716d64 309 if(s->bitstream_bpp < 24){
19716d64
LM
310 int p, i, y, u;
311 for(p=0; p<3; p++){
312 for(i=y=0; y<256; y++){
313 int len0 = s->len[0][y];
314 int limit = VLC_BITS - len0;
f45fcba3
LM
315 if(limit <= 0)
316 continue;
317 for(u=0; u<256; u++){
318 int len1 = s->len[p][u];
319 if(len1 > limit)
320 continue;
321 len[i] = len0 + len1;
322 bits[i] = (s->bits[0][y] << len1) + s->bits[p][u];
323 symbols[i] = (y<<8) + u;
324 if(symbols[i] != 0xffff) // reserved to mean "invalid"
325 i++;
19716d64
LM
326 }
327 }
328 free_vlc(&s->vlc[3+p]);
acc0e0c8 329 init_vlc_sparse(&s->vlc[3+p], VLC_BITS, i, len, 1, 1, bits, 2, 2, symbols, 2, 2, 0);
19716d64 330 }
8be6dac8
LM
331 }else{
332 uint8_t (*map)[4] = (uint8_t(*)[4])s->pix_bgr_map;
333 int i, b, g, r, code;
334 int p0 = s->decorrelate;
335 int p1 = !s->decorrelate;
336 // restrict the range to +/-16 becaues that's pretty much guaranteed to
337 // cover all the combinations that fit in 11 bits total, and it doesn't
338 // matter if we miss a few rare codes.
339 for(i=0, g=-16; g<16; g++){
340 int len0 = s->len[p0][g&255];
341 int limit0 = VLC_BITS - len0;
342 if(limit0 < 2)
343 continue;
344 for(b=-16; b<16; b++){
345 int len1 = s->len[p1][b&255];
346 int limit1 = limit0 - len1;
347 if(limit1 < 1)
348 continue;
349 code = (s->bits[p0][g&255] << len1) + s->bits[p1][b&255];
350 for(r=-16; r<16; r++){
351 int len2 = s->len[2][r&255];
352 if(len2 > limit1)
353 continue;
354 len[i] = len0 + len1 + len2;
355 bits[i] = (code << len2) + s->bits[2][r&255];
356 if(s->decorrelate){
357 map[i][G] = g;
358 map[i][B] = g+b;
359 map[i][R] = g+r;
360 }else{
361 map[i][B] = g;
362 map[i][G] = b;
363 map[i][R] = r;
364 }
365 i++;
366 }
367 }
368 }
369 free_vlc(&s->vlc[3]);
370 init_vlc(&s->vlc[3], VLC_BITS, i, len, 1, 1, bits, 2, 2, 0);
19716d64
LM
371 }
372}
373
11f18faf
MN
374static int read_huffman_tables(HYuvContext *s, uint8_t *src, int length){
375 GetBitContext gb;
376 int i;
115329f1 377
68f593b4 378 init_get_bits(&gb, src, length*8);
115329f1 379
11f18faf
MN
380 for(i=0; i<3; i++){
381 read_len_table(s->len[i], &gb);
115329f1 382
11f18faf
MN
383 if(generate_bits_table(s->bits[i], s->len[i])<0){
384 return -1;
385 }
386#if 0
387for(j=0; j<256; j++){
388printf("%6X, %2d, %3d\n", s->bits[i][j], s->len[i][j], j);
389}
390#endif
11087086 391 free_vlc(&s->vlc[i]);
073c2593 392 init_vlc(&s->vlc[i], VLC_BITS, 256, s->len[i], 1, 1, s->bits[i], 4, 4, 0);
11f18faf 393 }
115329f1 394
19716d64
LM
395 generate_joint_tables(s);
396
11087086 397 return (get_bits_count(&gb)+7)/8;
11f18faf
MN
398}
399
400static int read_old_huffman_tables(HYuvContext *s){
676b385c 401#if 1
11f18faf
MN
402 GetBitContext gb;
403 int i;
404
68f593b4 405 init_get_bits(&gb, classic_shift_luma, sizeof(classic_shift_luma)*8);
11f18faf 406 read_len_table(s->len[0], &gb);
68f593b4 407 init_get_bits(&gb, classic_shift_chroma, sizeof(classic_shift_chroma)*8);
11f18faf 408 read_len_table(s->len[1], &gb);
115329f1 409
11f18faf
MN
410 for(i=0; i<256; i++) s->bits[0][i] = classic_add_luma [i];
411 for(i=0; i<256; i++) s->bits[1][i] = classic_add_chroma[i];
412
413 if(s->bitstream_bpp >= 24){
414 memcpy(s->bits[1], s->bits[0], 256*sizeof(uint32_t));
415 memcpy(s->len[1] , s->len [0], 256*sizeof(uint8_t));
416 }
417 memcpy(s->bits[2], s->bits[1], 256*sizeof(uint32_t));
418 memcpy(s->len[2] , s->len [1], 256*sizeof(uint8_t));
115329f1 419
11087086
LM
420 for(i=0; i<3; i++){
421 free_vlc(&s->vlc[i]);
073c2593 422 init_vlc(&s->vlc[i], VLC_BITS, 256, s->len[i], 1, 1, s->bits[i], 4, 4, 0);
11087086 423 }
115329f1 424
19716d64
LM
425 generate_joint_tables(s);
426
11f18faf
MN
427 return 0;
428#else
267f7edc 429 av_log(s->avctx, AV_LOG_DEBUG, "v1 huffyuv is not supported \n");
11f18faf
MN
430 return -1;
431#endif
432}
433
5ef251e5 434static av_cold void alloc_temp(HYuvContext *s){
ae2f1d46 435 int i;
115329f1 436
ae2f1d46
MN
437 if(s->bitstream_bpp<24){
438 for(i=0; i<3; i++){
439 s->temp[i]= av_malloc(s->width + 16);
440 }
441 }else{
d2bfaf8a
LM
442 for(i=0; i<2; i++){
443 s->temp[i]= av_malloc(4*s->width + 16);
444 }
ae2f1d46
MN
445 }
446}
447
5ef251e5 448static av_cold int common_init(AVCodecContext *avctx){
11f18faf 449 HYuvContext *s = avctx->priv_data;
11f18faf
MN
450
451 s->avctx= avctx;
452 s->flags= avctx->flags;
115329f1 453
1d98dca3 454 dsputil_init(&s->dsp, avctx);
115329f1 455
0ecca7a4
MN
456 s->width= avctx->width;
457 s->height= avctx->height;
458 assert(s->width>0 && s->height>0);
115329f1 459
0ecca7a4
MN
460 return 0;
461}
462
b250f9c6 463#if CONFIG_HUFFYUV_DECODER || CONFIG_FFVHUFF_DECODER
98a6fff9 464static av_cold int decode_init(AVCodecContext *avctx)
0ecca7a4
MN
465{
466 HYuvContext *s = avctx->priv_data;
467
468 common_init(avctx);
11087086 469 memset(s->vlc, 0, 3*sizeof(VLC));
115329f1 470
492cd3a9 471 avctx->coded_frame= &s->picture;
0ecca7a4 472 s->interlaced= s->height > 288;
1e491e29 473
11f18faf 474s->bgr32=1;
11f18faf
MN
475//if(avctx->extradata)
476// printf("extradata:%X, extradata_size:%d\n", *(uint32_t*)avctx->extradata, avctx->extradata_size);
477 if(avctx->extradata_size){
dd1c8f3e 478 if((avctx->bits_per_coded_sample&7) && avctx->bits_per_coded_sample != 12)
11f18faf
MN
479 s->version=1; // do such files exist at all?
480 else
481 s->version=2;
482 }else
483 s->version=0;
115329f1 484
11f18faf 485 if(s->version==2){
42dd22c4 486 int method, interlace;
11f18faf
MN
487
488 method= ((uint8_t*)avctx->extradata)[0];
489 s->decorrelate= method&64 ? 1 : 0;
490 s->predictor= method&63;
491 s->bitstream_bpp= ((uint8_t*)avctx->extradata)[1];
115329f1 492 if(s->bitstream_bpp==0)
dd1c8f3e 493 s->bitstream_bpp= avctx->bits_per_coded_sample&~7;
42dd22c4
LM
494 interlace= (((uint8_t*)avctx->extradata)[2] & 0x30) >> 4;
495 s->interlaced= (interlace==1) ? 1 : (interlace==2) ? 0 : s->interlaced;
11087086 496 s->context= ((uint8_t*)avctx->extradata)[2] & 0x40 ? 1 : 0;
115329f1 497
11f18faf
MN
498 if(read_huffman_tables(s, ((uint8_t*)avctx->extradata)+4, avctx->extradata_size) < 0)
499 return -1;
500 }else{
dd1c8f3e 501 switch(avctx->bits_per_coded_sample&7){
11f18faf
MN
502 case 1:
503 s->predictor= LEFT;
504 s->decorrelate= 0;
505 break;
506 case 2:
507 s->predictor= LEFT;
508 s->decorrelate= 1;
509 break;
510 case 3:
511 s->predictor= PLANE;
dd1c8f3e 512 s->decorrelate= avctx->bits_per_coded_sample >= 24;
11f18faf
MN
513 break;
514 case 4:
515 s->predictor= MEDIAN;
516 s->decorrelate= 0;
517 break;
518 default:
519 s->predictor= LEFT; //OLD
520 s->decorrelate= 0;
521 break;
522 }
dd1c8f3e 523 s->bitstream_bpp= avctx->bits_per_coded_sample & ~7;
11087086 524 s->context= 0;
115329f1 525
11f18faf
MN
526 if(read_old_huffman_tables(s) < 0)
527 return -1;
528 }
115329f1 529
11f18faf
MN
530 switch(s->bitstream_bpp){
531 case 12:
532 avctx->pix_fmt = PIX_FMT_YUV420P;
11f18faf
MN
533 break;
534 case 16:
535 if(s->yuy2){
71e445fc 536 avctx->pix_fmt = PIX_FMT_YUYV422;
11f18faf
MN
537 }else{
538 avctx->pix_fmt = PIX_FMT_YUV422P;
11f18faf
MN
539 }
540 break;
541 case 24:
542 case 32:
543 if(s->bgr32){
71e445fc 544 avctx->pix_fmt = PIX_FMT_RGB32;
11f18faf
MN
545 }else{
546 avctx->pix_fmt = PIX_FMT_BGR24;
11f18faf
MN
547 }
548 break;
549 default:
550 assert(0);
11f18faf 551 }
115329f1 552
ae2f1d46 553 alloc_temp(s);
115329f1 554
dd1c8f3e 555// av_log(NULL, AV_LOG_DEBUG, "pred:%d bpp:%d hbpp:%d il:%d\n", s->predictor, s->bitstream_bpp, avctx->bits_per_coded_sample, s->interlaced);
07140e39 556
11f18faf
MN
557 return 0;
558}
b250f9c6 559#endif /* CONFIG_HUFFYUV_DECODER || CONFIG_FFVHUFF_DECODER */
11f18faf 560
b250f9c6 561#if CONFIG_HUFFYUV_ENCODER || CONFIG_FFVHUFF_ENCODER
11087086 562static int store_table(HYuvContext *s, uint8_t *len, uint8_t *buf){
11f18faf 563 int i;
11087086 564 int index= 0;
11f18faf
MN
565
566 for(i=0; i<256;){
11f18faf 567 int val= len[i];
a003ee9a 568 int repeat=0;
115329f1 569
a003ee9a
MN
570 for(; i<256 && len[i]==val && repeat<255; i++)
571 repeat++;
115329f1 572
a003ee9a 573 assert(val < 32 && val >0 && repeat<256 && repeat>0);
11f18faf 574 if(repeat>7){
11087086
LM
575 buf[index++]= val;
576 buf[index++]= repeat;
11f18faf 577 }else{
11087086 578 buf[index++]= val | (repeat<<5);
11f18faf
MN
579 }
580 }
115329f1 581
11087086 582 return index;
11f18faf
MN
583}
584
98a6fff9 585static av_cold int encode_init(AVCodecContext *avctx)
11f18faf
MN
586{
587 HYuvContext *s = avctx->priv_data;
0ecca7a4 588 int i, j;
11f18faf 589
0ecca7a4 590 common_init(avctx);
115329f1 591
0ecca7a4
MN
592 avctx->extradata= av_mallocz(1024*30); // 256*3+4 == 772
593 avctx->stats_out= av_mallocz(1024*30); // 21*256*3(%llu ) + 3(\n) + 1(0) = 16132
11f18faf 594 s->version=2;
115329f1 595
492cd3a9 596 avctx->coded_frame= &s->picture;
115329f1 597
11f18faf 598 switch(avctx->pix_fmt){
152ba68c 599 case PIX_FMT_YUV420P:
152ba68c
MN
600 s->bitstream_bpp= 12;
601 break;
11f18faf
MN
602 case PIX_FMT_YUV422P:
603 s->bitstream_bpp= 16;
604 break;
d2bfaf8a
LM
605 case PIX_FMT_RGB32:
606 s->bitstream_bpp= 24;
607 break;
11f18faf 608 default:
9b879566 609 av_log(avctx, AV_LOG_ERROR, "format not supported\n");
11f18faf
MN
610 return -1;
611 }
dd1c8f3e 612 avctx->bits_per_coded_sample= s->bitstream_bpp;
11f18faf
MN
613 s->decorrelate= s->bitstream_bpp >= 24;
614 s->predictor= avctx->prediction_method;
ee598f7b 615 s->interlaced= avctx->flags&CODEC_FLAG_INTERLACED_ME ? 1 : 0;
11087086
LM
616 if(avctx->context_model==1){
617 s->context= avctx->context_model;
11087086
LM
618 if(s->flags & (CODEC_FLAG_PASS1|CODEC_FLAG_PASS2)){
619 av_log(avctx, AV_LOG_ERROR, "context=1 is not compatible with 2 pass huffyuv encoding\n");
620 return -1;
621 }
11087086 622 }else s->context= 0;
115329f1 623
f37b9768
LM
624 if(avctx->codec->id==CODEC_ID_HUFFYUV){
625 if(avctx->pix_fmt==PIX_FMT_YUV420P){
626 av_log(avctx, AV_LOG_ERROR, "Error: YV12 is not supported by huffyuv; use vcodec=ffvhuff or format=422p\n");
627 return -1;
628 }
629 if(avctx->context_model){
630 av_log(avctx, AV_LOG_ERROR, "Error: per-frame huffman tables are not supported by huffyuv; use vcodec=ffvhuff\n");
631 return -1;
632 }
0ecca7a4 633 if(s->interlaced != ( s->height > 288 ))
f37b9768 634 av_log(avctx, AV_LOG_INFO, "using huffyuv 2.2.0 or newer interlacing flag\n");
f37b9768 635 }
115329f1 636
d2bfaf8a
LM
637 if(s->bitstream_bpp>=24 && s->predictor==MEDIAN){
638 av_log(avctx, AV_LOG_ERROR, "Error: RGB is incompatible with median predictor\n");
639 return -1;
640 }
641
642 ((uint8_t*)avctx->extradata)[0]= s->predictor | (s->decorrelate << 6);
11f18faf 643 ((uint8_t*)avctx->extradata)[1]= s->bitstream_bpp;
42dd22c4 644 ((uint8_t*)avctx->extradata)[2]= s->interlaced ? 0x10 : 0x20;
11087086
LM
645 if(s->context)
646 ((uint8_t*)avctx->extradata)[2]|= 0x40;
11f18faf
MN
647 ((uint8_t*)avctx->extradata)[3]= 0;
648 s->avctx->extradata_size= 4;
115329f1 649
11f18faf
MN
650 if(avctx->stats_in){
651 char *p= avctx->stats_in;
115329f1 652
11f18faf
MN
653 for(i=0; i<3; i++)
654 for(j=0; j<256; j++)
655 s->stats[i][j]= 1;
656
657 for(;;){
658 for(i=0; i<3; i++){
659 char *next;
660
661 for(j=0; j<256; j++){
662 s->stats[i][j]+= strtol(p, &next, 0);
663 if(next==p) return -1;
664 p=next;
115329f1 665 }
11f18faf
MN
666 }
667 if(p[0]==0 || p[1]==0 || p[2]==0) break;
668 }
669 }else{
670 for(i=0; i<3; i++)
671 for(j=0; j<256; j++){
672 int d= FFMIN(j, 256-j);
115329f1 673
11f18faf
MN
674 s->stats[i][j]= 100000000/(d+1);
675 }
676 }
115329f1 677
11f18faf
MN
678 for(i=0; i<3; i++){
679 generate_len_table(s->len[i], s->stats[i], 256);
680
681 if(generate_bits_table(s->bits[i], s->len[i])<0){
682 return -1;
683 }
115329f1 684
11087086
LM
685 s->avctx->extradata_size+=
686 store_table(s, s->len[i], &((uint8_t*)s->avctx->extradata)[s->avctx->extradata_size]);
11f18faf
MN
687 }
688
11087086
LM
689 if(s->context){
690 for(i=0; i<3; i++){
0ecca7a4 691 int pels = s->width*s->height / (i?40:10);
11087086
LM
692 for(j=0; j<256; j++){
693 int d= FFMIN(j, 256-j);
694 s->stats[i][j]= pels/(d+1);
695 }
696 }
697 }else{
698 for(i=0; i<3; i++)
699 for(j=0; j<256; j++)
700 s->stats[i][j]= 0;
701 }
115329f1 702
dd1c8f3e 703// printf("pred:%d bpp:%d hbpp:%d il:%d\n", s->predictor, s->bitstream_bpp, avctx->bits_per_coded_sample, s->interlaced);
5fd74135 704
ae2f1d46
MN
705 alloc_temp(s);
706
11f18faf 707 s->picture_number=0;
5fd74135 708
11f18faf
MN
709 return 0;
710}
b250f9c6 711#endif /* CONFIG_HUFFYUV_ENCODER || CONFIG_FFVHUFF_ENCODER */
11f18faf 712
19716d64
LM
713/* TODO instead of restarting the read when the code isn't in the first level
714 * of the joint table, jump into the 2nd level of the individual table. */
715#define READ_2PIX(dst0, dst1, plane1){\
acc0e0c8
LM
716 uint16_t code = get_vlc2(&s->gb, s->vlc[3+plane1].table, VLC_BITS, 1);\
717 if(code != 0xffff){\
718 dst0 = code>>8;\
719 dst1 = code;\
19716d64
LM
720 }else{\
721 dst0 = get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3);\
722 dst1 = get_vlc2(&s->gb, s->vlc[plane1].table, VLC_BITS, 3);\
723 }\
724}
725
11f18faf
MN
726static void decode_422_bitstream(HYuvContext *s, int count){
727 int i;
5fd74135 728
11f18faf 729 count/=2;
115329f1 730
11f18faf 731 for(i=0; i<count; i++){
19716d64
LM
732 READ_2PIX(s->temp[0][2*i ], s->temp[1][i], 1);
733 READ_2PIX(s->temp[0][2*i+1], s->temp[2][i], 2);
11f18faf
MN
734 }
735}
736
152ba68c
MN
737static void decode_gray_bitstream(HYuvContext *s, int count){
738 int i;
115329f1 739
152ba68c 740 count/=2;
115329f1 741
152ba68c 742 for(i=0; i<count; i++){
19716d64 743 READ_2PIX(s->temp[0][2*i ], s->temp[0][2*i+1], 0);
152ba68c
MN
744 }
745}
746
b250f9c6 747#if CONFIG_HUFFYUV_ENCODER || CONFIG_FFVHUFF_ENCODER
0ecca7a4 748static int encode_422_bitstream(HYuvContext *s, int count){
11f18faf 749 int i;
115329f1 750
0ecca7a4
MN
751 if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < 2*4*count){
752 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
753 return -1;
754 }
115329f1 755
bf1a5a46
LM
756#define LOAD4\
757 int y0 = s->temp[0][2*i];\
758 int y1 = s->temp[0][2*i+1];\
759 int u0 = s->temp[1][i];\
760 int v0 = s->temp[2][i];
761
11f18faf
MN
762 count/=2;
763 if(s->flags&CODEC_FLAG_PASS1){
764 for(i=0; i<count; i++){
bf1a5a46
LM
765 LOAD4;
766 s->stats[0][y0]++;
767 s->stats[1][u0]++;
768 s->stats[0][y1]++;
769 s->stats[2][v0]++;
11f18faf 770 }
09b0499f
MN
771 }
772 if(s->avctx->flags2&CODEC_FLAG2_NO_OUTPUT)
773 return 0;
774 if(s->context){
11087086 775 for(i=0; i<count; i++){
bf1a5a46
LM
776 LOAD4;
777 s->stats[0][y0]++;
778 put_bits(&s->pb, s->len[0][y0], s->bits[0][y0]);
779 s->stats[1][u0]++;
780 put_bits(&s->pb, s->len[1][u0], s->bits[1][u0]);
781 s->stats[0][y1]++;
782 put_bits(&s->pb, s->len[0][y1], s->bits[0][y1]);
783 s->stats[2][v0]++;
784 put_bits(&s->pb, s->len[2][v0], s->bits[2][v0]);
11087086 785 }
11f18faf
MN
786 }else{
787 for(i=0; i<count; i++){
bf1a5a46
LM
788 LOAD4;
789 put_bits(&s->pb, s->len[0][y0], s->bits[0][y0]);
790 put_bits(&s->pb, s->len[1][u0], s->bits[1][u0]);
791 put_bits(&s->pb, s->len[0][y1], s->bits[0][y1]);
792 put_bits(&s->pb, s->len[2][v0], s->bits[2][v0]);
11f18faf
MN
793 }
794 }
0ecca7a4 795 return 0;
11f18faf
MN
796}
797
0ecca7a4 798static int encode_gray_bitstream(HYuvContext *s, int count){
152ba68c 799 int i;
115329f1 800
0ecca7a4
MN
801 if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < 4*count){
802 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
803 return -1;
804 }
805
bf1a5a46
LM
806#define LOAD2\
807 int y0 = s->temp[0][2*i];\
808 int y1 = s->temp[0][2*i+1];
809#define STAT2\
810 s->stats[0][y0]++;\
811 s->stats[0][y1]++;
812#define WRITE2\
813 put_bits(&s->pb, s->len[0][y0], s->bits[0][y0]);\
814 put_bits(&s->pb, s->len[0][y1], s->bits[0][y1]);
815
152ba68c
MN
816 count/=2;
817 if(s->flags&CODEC_FLAG_PASS1){
818 for(i=0; i<count; i++){
bf1a5a46
LM
819 LOAD2;
820 STAT2;
152ba68c 821 }
09b0499f
MN
822 }
823 if(s->avctx->flags2&CODEC_FLAG2_NO_OUTPUT)
824 return 0;
115329f1 825
09b0499f 826 if(s->context){
11087086 827 for(i=0; i<count; i++){
bf1a5a46
LM
828 LOAD2;
829 STAT2;
830 WRITE2;
11087086 831 }
152ba68c
MN
832 }else{
833 for(i=0; i<count; i++){
bf1a5a46
LM
834 LOAD2;
835 WRITE2;
152ba68c
MN
836 }
837 }
0ecca7a4 838 return 0;
152ba68c 839}
b250f9c6 840#endif /* CONFIG_HUFFYUV_ENCODER || CONFIG_FFVHUFF_ENCODER */
152ba68c 841
8be6dac8 842static av_always_inline void decode_bgr_1(HYuvContext *s, int count, int decorrelate, int alpha){
11f18faf 843 int i;
8be6dac8
LM
844 for(i=0; i<count; i++){
845 int code = get_vlc2(&s->gb, s->vlc[3].table, VLC_BITS, 1);
846 if(code != -1){
847 *(uint32_t*)&s->temp[0][4*i] = s->pix_bgr_map[code];
848 }else if(decorrelate){
849 s->temp[0][4*i+G] = get_vlc2(&s->gb, s->vlc[1].table, VLC_BITS, 3);
850 s->temp[0][4*i+B] = get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3) + s->temp[0][4*i+G];
851 s->temp[0][4*i+R] = get_vlc2(&s->gb, s->vlc[2].table, VLC_BITS, 3) + s->temp[0][4*i+G];
11f18faf 852 }else{
8be6dac8
LM
853 s->temp[0][4*i+B] = get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3);
854 s->temp[0][4*i+G] = get_vlc2(&s->gb, s->vlc[1].table, VLC_BITS, 3);
855 s->temp[0][4*i+R] = get_vlc2(&s->gb, s->vlc[2].table, VLC_BITS, 3);
11f18faf 856 }
8be6dac8
LM
857 if(alpha)
858 get_vlc2(&s->gb, s->vlc[2].table, VLC_BITS, 3); //?!
859 }
860}
861
862static void decode_bgr_bitstream(HYuvContext *s, int count){
863 if(s->decorrelate){
864 if(s->bitstream_bpp==24)
865 decode_bgr_1(s, count, 1, 0);
866 else
867 decode_bgr_1(s, count, 1, 1);
11f18faf 868 }else{
8be6dac8
LM
869 if(s->bitstream_bpp==24)
870 decode_bgr_1(s, count, 0, 0);
871 else
872 decode_bgr_1(s, count, 0, 1);
11f18faf
MN
873 }
874}
875
d2bfaf8a
LM
876static int encode_bgr_bitstream(HYuvContext *s, int count){
877 int i;
878
879 if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < 3*4*count){
880 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
881 return -1;
882 }
883
bf1a5a46
LM
884#define LOAD3\
885 int g= s->temp[0][4*i+G];\
886 int b= (s->temp[0][4*i+B] - g) & 0xff;\
d2bfaf8a 887 int r= (s->temp[0][4*i+R] - g) & 0xff;
bf1a5a46
LM
888#define STAT3\
889 s->stats[0][b]++;\
890 s->stats[1][g]++;\
d2bfaf8a 891 s->stats[2][r]++;
bf1a5a46
LM
892#define WRITE3\
893 put_bits(&s->pb, s->len[1][g], s->bits[1][g]);\
894 put_bits(&s->pb, s->len[0][b], s->bits[0][b]);\
895 put_bits(&s->pb, s->len[2][r], s->bits[2][r]);
896
897 if((s->flags&CODEC_FLAG_PASS1) && (s->avctx->flags2&CODEC_FLAG2_NO_OUTPUT)){
898 for(i=0; i<count; i++){
899 LOAD3;
900 STAT3;
d2bfaf8a
LM
901 }
902 }else if(s->context || (s->flags&CODEC_FLAG_PASS1)){
903 for(i=0; i<count; i++){
bf1a5a46
LM
904 LOAD3;
905 STAT3;
906 WRITE3;
d2bfaf8a
LM
907 }
908 }else{
909 for(i=0; i<count; i++){
bf1a5a46
LM
910 LOAD3;
911 WRITE3;
d2bfaf8a
LM
912 }
913 }
914 return 0;
915}
916
b250f9c6 917#if CONFIG_HUFFYUV_DECODER || CONFIG_FFVHUFF_DECODER
7c5ab7b8
MN
918static void draw_slice(HYuvContext *s, int y){
919 int h, cy;
7a06ff14 920 int offset[4];
115329f1
DB
921
922 if(s->avctx->draw_horiz_band==NULL)
7c5ab7b8 923 return;
115329f1 924
7c5ab7b8
MN
925 h= y - s->last_slice_end;
926 y -= h;
115329f1 927
7c5ab7b8
MN
928 if(s->bitstream_bpp==12){
929 cy= y>>1;
930 }else{
931 cy= y;
932 }
7a06ff14
MN
933
934 offset[0] = s->picture.linesize[0]*y;
935 offset[1] = s->picture.linesize[1]*cy;
936 offset[2] = s->picture.linesize[2]*cy;
937 offset[3] = 0;
7c5ab7b8
MN
938 emms_c();
939
3bb07d61 940 s->avctx->draw_horiz_band(s->avctx, &s->picture, offset, y, 3, h);
115329f1 941
7c5ab7b8
MN
942 s->last_slice_end= y + h;
943}
944
fb2cf1bc 945static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, const uint8_t *buf, int buf_size){
11f18faf
MN
946 HYuvContext *s = avctx->priv_data;
947 const int width= s->width;
948 const int width2= s->width>>1;
949 const int height= s->height;
22f3e8be 950 int fake_ystride, fake_ustride, fake_vstride;
492cd3a9 951 AVFrame * const p= &s->picture;
11087086 952 int table_size= 0;
11f18faf 953
492cd3a9 954 AVFrame *picture = data;
11f18faf 955
0ecca7a4 956 s->bitstream_buffer= av_fast_realloc(s->bitstream_buffer, &s->bitstream_buffer_size, buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
11f18faf 957
fb2cf1bc 958 s->dsp.bswap_buf((uint32_t*)s->bitstream_buffer, (const uint32_t*)buf, buf_size/4);
115329f1 959
e20c4069
MN
960 if(p->data[0])
961 avctx->release_buffer(avctx, p);
962
1e491e29
MN
963 p->reference= 0;
964 if(avctx->get_buffer(avctx, p) < 0){
9b879566 965 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1e491e29 966 return -1;
22f3e8be 967 }
115329f1 968
11087086
LM
969 if(s->context){
970 table_size = read_huffman_tables(s, s->bitstream_buffer, buf_size);
971 if(table_size < 0)
972 return -1;
973 }
974
e70e7a4b
MN
975 if((unsigned)(buf_size-table_size) >= INT_MAX/8)
976 return -1;
977
11087086 978 init_get_bits(&s->gb, s->bitstream_buffer+table_size, (buf_size-table_size)*8);
1e491e29
MN
979
980 fake_ystride= s->interlaced ? p->linesize[0]*2 : p->linesize[0];
981 fake_ustride= s->interlaced ? p->linesize[1]*2 : p->linesize[1];
982 fake_vstride= s->interlaced ? p->linesize[2]*2 : p->linesize[2];
115329f1 983
7c5ab7b8 984 s->last_slice_end= 0;
115329f1 985
11f18faf 986 if(s->bitstream_bpp<24){
152ba68c 987 int y, cy;
11f18faf
MN
988 int lefty, leftu, leftv;
989 int lefttopy, lefttopu, lefttopv;
115329f1 990
11f18faf 991 if(s->yuy2){
1e491e29
MN
992 p->data[0][3]= get_bits(&s->gb, 8);
993 p->data[0][2]= get_bits(&s->gb, 8);
994 p->data[0][1]= get_bits(&s->gb, 8);
995 p->data[0][0]= get_bits(&s->gb, 8);
115329f1 996
160d679c 997 av_log(avctx, AV_LOG_ERROR, "YUY2 output is not implemented yet\n");
11f18faf
MN
998 return -1;
999 }else{
115329f1 1000
1e491e29
MN
1001 leftv= p->data[2][0]= get_bits(&s->gb, 8);
1002 lefty= p->data[0][1]= get_bits(&s->gb, 8);
1003 leftu= p->data[1][0]= get_bits(&s->gb, 8);
1004 p->data[0][0]= get_bits(&s->gb, 8);
115329f1 1005
11f18faf
MN
1006 switch(s->predictor){
1007 case LEFT:
1008 case PLANE:
1009 decode_422_bitstream(s, width-2);
1e491e29 1010 lefty= add_left_prediction(p->data[0] + 2, s->temp[0], width-2, lefty);
11f18faf 1011 if(!(s->flags&CODEC_FLAG_GRAY)){
1e491e29
MN
1012 leftu= add_left_prediction(p->data[1] + 1, s->temp[1], width2-1, leftu);
1013 leftv= add_left_prediction(p->data[2] + 1, s->temp[2], width2-1, leftv);
11f18faf
MN
1014 }
1015
152ba68c 1016 for(cy=y=1; y<s->height; y++,cy++){
11f18faf 1017 uint8_t *ydst, *udst, *vdst;
115329f1 1018
152ba68c
MN
1019 if(s->bitstream_bpp==12){
1020 decode_gray_bitstream(s, width);
115329f1 1021
1e491e29 1022 ydst= p->data[0] + p->linesize[0]*y;
152ba68c
MN
1023
1024 lefty= add_left_prediction(ydst, s->temp[0], width, lefty);
1025 if(s->predictor == PLANE){
1026 if(y>s->interlaced)
1027 s->dsp.add_bytes(ydst, ydst - fake_ystride, width);
1028 }
1029 y++;
1030 if(y>=s->height) break;
1031 }
115329f1 1032
7c5ab7b8 1033 draw_slice(s, y);
115329f1 1034
1e491e29
MN
1035 ydst= p->data[0] + p->linesize[0]*y;
1036 udst= p->data[1] + p->linesize[1]*cy;
1037 vdst= p->data[2] + p->linesize[2]*cy;
115329f1 1038
152ba68c 1039 decode_422_bitstream(s, width);
11f18faf
MN
1040 lefty= add_left_prediction(ydst, s->temp[0], width, lefty);
1041 if(!(s->flags&CODEC_FLAG_GRAY)){
1042 leftu= add_left_prediction(udst, s->temp[1], width2, leftu);
1043 leftv= add_left_prediction(vdst, s->temp[2], width2, leftv);
1044 }
1045 if(s->predictor == PLANE){
152ba68c 1046 if(cy>s->interlaced){
11f18faf
MN
1047 s->dsp.add_bytes(ydst, ydst - fake_ystride, width);
1048 if(!(s->flags&CODEC_FLAG_GRAY)){
1049 s->dsp.add_bytes(udst, udst - fake_ustride, width2);
1050 s->dsp.add_bytes(vdst, vdst - fake_vstride, width2);
1051 }
1052 }
1053 }
1054 }
7c5ab7b8 1055 draw_slice(s, height);
115329f1 1056
11f18faf
MN
1057 break;
1058 case MEDIAN:
1059 /* first line except first 2 pixels is left predicted */
1060 decode_422_bitstream(s, width-2);
1e491e29 1061 lefty= add_left_prediction(p->data[0] + 2, s->temp[0], width-2, lefty);
11f18faf 1062 if(!(s->flags&CODEC_FLAG_GRAY)){
1e491e29
MN
1063 leftu= add_left_prediction(p->data[1] + 1, s->temp[1], width2-1, leftu);
1064 leftv= add_left_prediction(p->data[2] + 1, s->temp[2], width2-1, leftv);
11f18faf 1065 }
115329f1 1066
152ba68c 1067 cy=y=1;
115329f1 1068
11f18faf
MN
1069 /* second line is left predicted for interlaced case */
1070 if(s->interlaced){
1071 decode_422_bitstream(s, width);
1e491e29 1072 lefty= add_left_prediction(p->data[0] + p->linesize[0], s->temp[0], width, lefty);
11f18faf 1073 if(!(s->flags&CODEC_FLAG_GRAY)){
1e491e29
MN
1074 leftu= add_left_prediction(p->data[1] + p->linesize[2], s->temp[1], width2, leftu);
1075 leftv= add_left_prediction(p->data[2] + p->linesize[1], s->temp[2], width2, leftv);
11f18faf 1076 }
152ba68c 1077 y++; cy++;
11f18faf
MN
1078 }
1079
1080 /* next 4 pixels are left predicted too */
1081 decode_422_bitstream(s, 4);
1e491e29 1082 lefty= add_left_prediction(p->data[0] + fake_ystride, s->temp[0], 4, lefty);
11f18faf 1083 if(!(s->flags&CODEC_FLAG_GRAY)){
1e491e29
MN
1084 leftu= add_left_prediction(p->data[1] + fake_ustride, s->temp[1], 2, leftu);
1085 leftv= add_left_prediction(p->data[2] + fake_vstride, s->temp[2], 2, leftv);
11f18faf
MN
1086 }
1087
1088 /* next line except the first 4 pixels is median predicted */
1e491e29 1089 lefttopy= p->data[0][3];
11f18faf 1090 decode_422_bitstream(s, width-4);
3daa434a 1091 s->dsp.add_hfyu_median_prediction(p->data[0] + fake_ystride+4, p->data[0]+4, s->temp[0], width-4, &lefty, &lefttopy);
11f18faf 1092 if(!(s->flags&CODEC_FLAG_GRAY)){
1e491e29
MN
1093 lefttopu= p->data[1][1];
1094 lefttopv= p->data[2][1];
3daa434a
LM
1095 s->dsp.add_hfyu_median_prediction(p->data[1] + fake_ustride+2, p->data[1]+2, s->temp[1], width2-2, &leftu, &lefttopu);
1096 s->dsp.add_hfyu_median_prediction(p->data[2] + fake_vstride+2, p->data[2]+2, s->temp[2], width2-2, &leftv, &lefttopv);
11f18faf 1097 }
152ba68c 1098 y++; cy++;
115329f1 1099
152ba68c 1100 for(; y<height; y++,cy++){
11f18faf 1101 uint8_t *ydst, *udst, *vdst;
152ba68c
MN
1102
1103 if(s->bitstream_bpp==12){
1104 while(2*cy > y){
1105 decode_gray_bitstream(s, width);
1e491e29 1106 ydst= p->data[0] + p->linesize[0]*y;
3daa434a 1107 s->dsp.add_hfyu_median_prediction(ydst, ydst - fake_ystride, s->temp[0], width, &lefty, &lefttopy);
152ba68c
MN
1108 y++;
1109 }
1110 if(y>=height) break;
1111 }
7c5ab7b8 1112 draw_slice(s, y);
152ba68c 1113
11f18faf 1114 decode_422_bitstream(s, width);
152ba68c 1115
1e491e29
MN
1116 ydst= p->data[0] + p->linesize[0]*y;
1117 udst= p->data[1] + p->linesize[1]*cy;
1118 vdst= p->data[2] + p->linesize[2]*cy;
11f18faf 1119
3daa434a 1120 s->dsp.add_hfyu_median_prediction(ydst, ydst - fake_ystride, s->temp[0], width, &lefty, &lefttopy);
11f18faf 1121 if(!(s->flags&CODEC_FLAG_GRAY)){
3daa434a
LM
1122 s->dsp.add_hfyu_median_prediction(udst, udst - fake_ustride, s->temp[1], width2, &leftu, &lefttopu);
1123 s->dsp.add_hfyu_median_prediction(vdst, vdst - fake_vstride, s->temp[2], width2, &leftv, &lefttopv);
11f18faf
MN
1124 }
1125 }
7c5ab7b8
MN
1126
1127 draw_slice(s, height);
11f18faf
MN
1128 break;
1129 }
1130 }
1131 }else{
1132 int y;
1133 int leftr, leftg, leftb;
1e491e29 1134 const int last_line= (height-1)*p->linesize[0];
115329f1 1135
11f18faf 1136 if(s->bitstream_bpp==32){
0722ccdb
MN
1137 skip_bits(&s->gb, 8);
1138 leftr= p->data[0][last_line+R]= get_bits(&s->gb, 8);
1139 leftg= p->data[0][last_line+G]= get_bits(&s->gb, 8);
1140 leftb= p->data[0][last_line+B]= get_bits(&s->gb, 8);
11f18faf 1141 }else{
0722ccdb
MN
1142 leftr= p->data[0][last_line+R]= get_bits(&s->gb, 8);
1143 leftg= p->data[0][last_line+G]= get_bits(&s->gb, 8);
1144 leftb= p->data[0][last_line+B]= get_bits(&s->gb, 8);
11f18faf
MN
1145 skip_bits(&s->gb, 8);
1146 }
115329f1 1147
11f18faf
MN
1148 if(s->bgr32){
1149 switch(s->predictor){
1150 case LEFT:
1151 case PLANE:
1152 decode_bgr_bitstream(s, width-1);
1e491e29 1153 add_left_prediction_bgr32(p->data[0] + last_line+4, s->temp[0], width-1, &leftr, &leftg, &leftb);
11f18faf 1154
90b5b51e 1155 for(y=s->height-2; y>=0; y--){ //Yes it is stored upside down.
11f18faf 1156 decode_bgr_bitstream(s, width);
115329f1 1157
1e491e29 1158 add_left_prediction_bgr32(p->data[0] + p->linesize[0]*y, s->temp[0], width, &leftr, &leftg, &leftb);
11f18faf 1159 if(s->predictor == PLANE){
fc0be57f 1160 if((y&s->interlaced)==0 && y<s->height-1-s->interlaced){
115329f1 1161 s->dsp.add_bytes(p->data[0] + p->linesize[0]*y,
1e491e29 1162 p->data[0] + p->linesize[0]*y + fake_ystride, fake_ystride);
11f18faf
MN
1163 }
1164 }
1165 }
160d679c 1166 draw_slice(s, height); // just 1 large slice as this is not possible in reverse order
11f18faf
MN
1167 break;
1168 default:
9b879566 1169 av_log(avctx, AV_LOG_ERROR, "prediction type not supported!\n");
11f18faf
MN
1170 }
1171 }else{
1172
160d679c 1173 av_log(avctx, AV_LOG_ERROR, "BGR24 output is not implemented yet\n");
11f18faf
MN
1174 return -1;
1175 }
1176 }
1177 emms_c();
115329f1 1178
1e491e29 1179 *picture= *p;
492cd3a9 1180 *data_size = sizeof(AVFrame);
115329f1 1181
1adc29ee 1182 return (get_bits_count(&s->gb)+31)/32*4 + table_size;
11f18faf 1183}
b250f9c6 1184#endif /* CONFIG_HUFFYUV_DECODER || CONFIG_FFVHUFF_DECODER */
11f18faf 1185
0ecca7a4
MN
1186static int common_end(HYuvContext *s){
1187 int i;
115329f1 1188
0ecca7a4
MN
1189 for(i=0; i<3; i++){
1190 av_freep(&s->temp[i]);
1191 }
1192 return 0;
1193}
1194
b250f9c6 1195#if CONFIG_HUFFYUV_DECODER || CONFIG_FFVHUFF_DECODER
98a6fff9 1196static av_cold int decode_end(AVCodecContext *avctx)
11f18faf
MN
1197{
1198 HYuvContext *s = avctx->priv_data;
1199 int i;
115329f1 1200
0ecca7a4
MN
1201 common_end(s);
1202 av_freep(&s->bitstream_buffer);
115329f1 1203
7b62bb2b 1204 for(i=0; i<6; i++){
11f18faf
MN
1205 free_vlc(&s->vlc[i]);
1206 }
1e491e29 1207
11f18faf
MN
1208 return 0;
1209}
b250f9c6 1210#endif /* CONFIG_HUFFYUV_DECODER || CONFIG_FFVHUFF_DECODER */
11f18faf 1211
b250f9c6 1212#if CONFIG_HUFFYUV_ENCODER || CONFIG_FFVHUFF_ENCODER
11f18faf
MN
1213static int encode_frame(AVCodecContext *avctx, unsigned char *buf, int buf_size, void *data){
1214 HYuvContext *s = avctx->priv_data;
492cd3a9 1215 AVFrame *pict = data;
11f18faf
MN
1216 const int width= s->width;
1217 const int width2= s->width>>1;
1218 const int height= s->height;
1219 const int fake_ystride= s->interlaced ? pict->linesize[0]*2 : pict->linesize[0];
1220 const int fake_ustride= s->interlaced ? pict->linesize[1]*2 : pict->linesize[1];
1221 const int fake_vstride= s->interlaced ? pict->linesize[2]*2 : pict->linesize[2];
492cd3a9 1222 AVFrame * const p= &s->picture;
11087086 1223 int i, j, size=0;
11f18faf 1224
1e491e29 1225 *p = *pict;
aaa1e4cd
MN
1226 p->pict_type= FF_I_TYPE;
1227 p->key_frame= 1;
115329f1 1228
11087086
LM
1229 if(s->context){
1230 for(i=0; i<3; i++){
1231 generate_len_table(s->len[i], s->stats[i], 256);
1232 if(generate_bits_table(s->bits[i], s->len[i])<0)
1233 return -1;
1234 size+= store_table(s, s->len[i], &buf[size]);
1235 }
1236
1237 for(i=0; i<3; i++)
1238 for(j=0; j<256; j++)
1239 s->stats[i][j] >>= 1;
1240 }
1241
1242 init_put_bits(&s->pb, buf+size, buf_size-size);
1243
152ba68c
MN
1244 if(avctx->pix_fmt == PIX_FMT_YUV422P || avctx->pix_fmt == PIX_FMT_YUV420P){
1245 int lefty, leftu, leftv, y, cy;
11f18faf 1246
1e491e29
MN
1247 put_bits(&s->pb, 8, leftv= p->data[2][0]);
1248 put_bits(&s->pb, 8, lefty= p->data[0][1]);
1249 put_bits(&s->pb, 8, leftu= p->data[1][0]);
1250 put_bits(&s->pb, 8, p->data[0][0]);
115329f1 1251
1e491e29
MN
1252 lefty= sub_left_prediction(s, s->temp[0], p->data[0]+2, width-2 , lefty);
1253 leftu= sub_left_prediction(s, s->temp[1], p->data[1]+1, width2-1, leftu);
1254 leftv= sub_left_prediction(s, s->temp[2], p->data[2]+1, width2-1, leftv);
115329f1 1255
11f18faf 1256 encode_422_bitstream(s, width-2);
115329f1 1257
11f18faf
MN
1258 if(s->predictor==MEDIAN){
1259 int lefttopy, lefttopu, lefttopv;
152ba68c 1260 cy=y=1;
11f18faf 1261 if(s->interlaced){
1e491e29
MN
1262 lefty= sub_left_prediction(s, s->temp[0], p->data[0]+p->linesize[0], width , lefty);
1263 leftu= sub_left_prediction(s, s->temp[1], p->data[1]+p->linesize[1], width2, leftu);
1264 leftv= sub_left_prediction(s, s->temp[2], p->data[2]+p->linesize[2], width2, leftv);
115329f1 1265
11f18faf 1266 encode_422_bitstream(s, width);
152ba68c 1267 y++; cy++;
11f18faf 1268 }
115329f1 1269
1e491e29 1270 lefty= sub_left_prediction(s, s->temp[0], p->data[0]+fake_ystride, 4, lefty);
07140e39
MN
1271 leftu= sub_left_prediction(s, s->temp[1], p->data[1]+fake_ustride, 2, leftu);
1272 leftv= sub_left_prediction(s, s->temp[2], p->data[2]+fake_vstride, 2, leftv);
115329f1 1273
11f18faf 1274 encode_422_bitstream(s, 4);
152ba68c 1275
1e491e29
MN
1276 lefttopy= p->data[0][3];
1277 lefttopu= p->data[1][1];
1278 lefttopv= p->data[2][1];
84705403
MN
1279 s->dsp.sub_hfyu_median_prediction(s->temp[0], p->data[0]+4, p->data[0] + fake_ystride+4, width-4 , &lefty, &lefttopy);
1280 s->dsp.sub_hfyu_median_prediction(s->temp[1], p->data[1]+2, p->data[1] + fake_ustride+2, width2-2, &leftu, &lefttopu);
1281 s->dsp.sub_hfyu_median_prediction(s->temp[2], p->data[2]+2, p->data[2] + fake_vstride+2, width2-2, &leftv, &lefttopv);
11f18faf 1282 encode_422_bitstream(s, width-4);
152ba68c 1283 y++; cy++;
11f18faf 1284
152ba68c 1285 for(; y<height; y++,cy++){
11f18faf 1286 uint8_t *ydst, *udst, *vdst;
115329f1 1287
152ba68c
MN
1288 if(s->bitstream_bpp==12){
1289 while(2*cy > y){
1e491e29 1290 ydst= p->data[0] + p->linesize[0]*y;
84705403 1291 s->dsp.sub_hfyu_median_prediction(s->temp[0], ydst - fake_ystride, ydst, width , &lefty, &lefttopy);
152ba68c
MN
1292 encode_gray_bitstream(s, width);
1293 y++;
1294 }
1295 if(y>=height) break;
1296 }
1e491e29
MN
1297 ydst= p->data[0] + p->linesize[0]*y;
1298 udst= p->data[1] + p->linesize[1]*cy;
1299 vdst= p->data[2] + p->linesize[2]*cy;
11f18faf 1300
84705403
MN
1301 s->dsp.sub_hfyu_median_prediction(s->temp[0], ydst - fake_ystride, ydst, width , &lefty, &lefttopy);
1302 s->dsp.sub_hfyu_median_prediction(s->temp[1], udst - fake_ustride, udst, width2, &leftu, &lefttopu);
1303 s->dsp.sub_hfyu_median_prediction(s->temp[2], vdst - fake_vstride, vdst, width2, &leftv, &lefttopv);
11f18faf
MN
1304
1305 encode_422_bitstream(s, width);
1306 }
1307 }else{
152ba68c 1308 for(cy=y=1; y<height; y++,cy++){
11f18faf 1309 uint8_t *ydst, *udst, *vdst;
115329f1 1310
152ba68c
MN
1311 /* encode a luma only line & y++ */
1312 if(s->bitstream_bpp==12){
1e491e29 1313 ydst= p->data[0] + p->linesize[0]*y;
152ba68c
MN
1314
1315 if(s->predictor == PLANE && s->interlaced < y){
7c5ab7b8 1316 s->dsp.diff_bytes(s->temp[1], ydst, ydst - fake_ystride, width);
152ba68c 1317
7c5ab7b8 1318 lefty= sub_left_prediction(s, s->temp[0], s->temp[1], width , lefty);
152ba68c 1319 }else{
7c5ab7b8 1320 lefty= sub_left_prediction(s, s->temp[0], ydst, width , lefty);
152ba68c
MN
1321 }
1322 encode_gray_bitstream(s, width);
1323 y++;
1324 if(y>=height) break;
1325 }
115329f1 1326
1e491e29
MN
1327 ydst= p->data[0] + p->linesize[0]*y;
1328 udst= p->data[1] + p->linesize[1]*cy;
1329 vdst= p->data[2] + p->linesize[2]*cy;
11f18faf 1330
152ba68c 1331 if(s->predictor == PLANE && s->interlaced < cy){
7c5ab7b8
MN
1332 s->dsp.diff_bytes(s->temp[1], ydst, ydst - fake_ystride, width);
1333 s->dsp.diff_bytes(s->temp[2], udst, udst - fake_ustride, width2);
ae2f1d46 1334 s->dsp.diff_bytes(s->temp[2] + width2, vdst, vdst - fake_vstride, width2);
11f18faf 1335
7c5ab7b8
MN
1336 lefty= sub_left_prediction(s, s->temp[0], s->temp[1], width , lefty);
1337 leftu= sub_left_prediction(s, s->temp[1], s->temp[2], width2, leftu);
ae2f1d46 1338 leftv= sub_left_prediction(s, s->temp[2], s->temp[2] + width2, width2, leftv);
11f18faf 1339 }else{
7c5ab7b8
MN
1340 lefty= sub_left_prediction(s, s->temp[0], ydst, width , lefty);
1341 leftu= sub_left_prediction(s, s->temp[1], udst, width2, leftu);
1342 leftv= sub_left_prediction(s, s->temp[2], vdst, width2, leftv);
11f18faf
MN
1343 }
1344
1345 encode_422_bitstream(s, width);
1346 }
115329f1 1347 }
d2bfaf8a
LM
1348 }else if(avctx->pix_fmt == PIX_FMT_RGB32){
1349 uint8_t *data = p->data[0] + (height-1)*p->linesize[0];
1350 const int stride = -p->linesize[0];
1351 const int fake_stride = -fake_ystride;
1352 int y;
1353 int leftr, leftg, leftb;
1354
1355 put_bits(&s->pb, 8, leftr= data[R]);
1356 put_bits(&s->pb, 8, leftg= data[G]);
1357 put_bits(&s->pb, 8, leftb= data[B]);
1358 put_bits(&s->pb, 8, 0);
1359
1360 sub_left_prediction_bgr32(s, s->temp[0], data+4, width-1, &leftr, &leftg, &leftb);
1361 encode_bgr_bitstream(s, width-1);
1362
1363 for(y=1; y<s->height; y++){
1364 uint8_t *dst = data + y*stride;
1365 if(s->predictor == PLANE && s->interlaced < y){
1366 s->dsp.diff_bytes(s->temp[1], dst, dst - fake_stride, width*4);
1367 sub_left_prediction_bgr32(s, s->temp[0], s->temp[1], width, &leftr, &leftg, &leftb);
1368 }else{
1369 sub_left_prediction_bgr32(s, s->temp[0], dst, width, &leftr, &leftg, &leftb);
1370 }
1371 encode_bgr_bitstream(s, width);
1372 }
11f18faf 1373 }else{
9b879566 1374 av_log(avctx, AV_LOG_ERROR, "Format not supported!\n");
11f18faf
MN
1375 }
1376 emms_c();
115329f1 1377
11087086 1378 size+= (put_bits_count(&s->pb)+31)/8;
300a3d0d
MN
1379 put_bits(&s->pb, 16, 0);
1380 put_bits(&s->pb, 15, 0);
11087086 1381 size/= 4;
115329f1 1382
11f18faf
MN
1383 if((s->flags&CODEC_FLAG_PASS1) && (s->picture_number&31)==0){
1384 int j;
1385 char *p= avctx->stats_out;
2fc8ea24 1386 char *end= p + 1024*30;
11f18faf
MN
1387 for(i=0; i<3; i++){
1388 for(j=0; j<256; j++){
4733abcb 1389 snprintf(p, end-p, "%"PRIu64" ", s->stats[i][j]);
11f18faf
MN
1390 p+= strlen(p);
1391 s->stats[i][j]= 0;
1392 }
2fc8ea24 1393 snprintf(p, end-p, "\n");
11f18faf
MN
1394 p++;
1395 }
390f9f31
LM
1396 } else
1397 avctx->stats_out[0] = '\0';
09b0499f 1398 if(!(s->avctx->flags2 & CODEC_FLAG2_NO_OUTPUT)){
152ba68c 1399 flush_put_bits(&s->pb);
3d2e8cce 1400 s->dsp.bswap_buf((uint32_t*)buf, (uint32_t*)buf, size);
11f18faf 1401 }
115329f1 1402
11f18faf 1403 s->picture_number++;
1e491e29 1404
11f18faf
MN
1405 return size*4;
1406}
1407
98a6fff9 1408static av_cold int encode_end(AVCodecContext *avctx)
11f18faf 1409{
0ecca7a4 1410 HYuvContext *s = avctx->priv_data;
115329f1 1411
0ecca7a4 1412 common_end(s);
11f18faf
MN
1413
1414 av_freep(&avctx->extradata);
1415 av_freep(&avctx->stats_out);
115329f1 1416
11f18faf
MN
1417 return 0;
1418}
b250f9c6 1419#endif /* CONFIG_HUFFYUV_ENCODER || CONFIG_FFVHUFF_ENCODER */
11f18faf 1420
b250f9c6 1421#if CONFIG_HUFFYUV_DECODER
11f18faf
MN
1422AVCodec huffyuv_decoder = {
1423 "huffyuv",
1424 CODEC_TYPE_VIDEO,
1425 CODEC_ID_HUFFYUV,
1426 sizeof(HYuvContext),
1427 decode_init,
1428 NULL,
1429 decode_end,
1430 decode_frame,
7c5ab7b8 1431 CODEC_CAP_DR1 | CODEC_CAP_DRAW_HORIZ_BAND,
bcdb2378 1432 NULL,
fe4bf374 1433 .long_name = NULL_IF_CONFIG_SMALL("Huffyuv / HuffYUV"),
11f18faf 1434};
2a43a093 1435#endif
11f18faf 1436
b250f9c6 1437#if CONFIG_FFVHUFF_DECODER
f37b9768
LM
1438AVCodec ffvhuff_decoder = {
1439 "ffvhuff",
1440 CODEC_TYPE_VIDEO,
1441 CODEC_ID_FFVHUFF,
1442 sizeof(HYuvContext),
1443 decode_init,
1444 NULL,
1445 decode_end,
1446 decode_frame,
1447 CODEC_CAP_DR1 | CODEC_CAP_DRAW_HORIZ_BAND,
bcdb2378 1448 NULL,
fe4bf374 1449 .long_name = NULL_IF_CONFIG_SMALL("Huffyuv FFmpeg variant"),
f37b9768 1450};
62bb489b 1451#endif
f37b9768 1452
b250f9c6 1453#if CONFIG_HUFFYUV_ENCODER
11f18faf
MN
1454AVCodec huffyuv_encoder = {
1455 "huffyuv",
1456 CODEC_TYPE_VIDEO,
1457 CODEC_ID_HUFFYUV,
1458 sizeof(HYuvContext),
1459 encode_init,
1460 encode_frame,
1461 encode_end,
eacced45 1462 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV422P, PIX_FMT_RGB32, PIX_FMT_NONE},
fe4bf374 1463 .long_name = NULL_IF_CONFIG_SMALL("Huffyuv / HuffYUV"),
11f18faf 1464};
f544a5fc 1465#endif
5fd74135 1466
b250f9c6 1467#if CONFIG_FFVHUFF_ENCODER
f37b9768
LM
1468AVCodec ffvhuff_encoder = {
1469 "ffvhuff",
1470 CODEC_TYPE_VIDEO,
1471 CODEC_ID_FFVHUFF,
1472 sizeof(HYuvContext),
1473 encode_init,
1474 encode_frame,
1475 encode_end,
eacced45 1476 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_RGB32, PIX_FMT_NONE},
fe4bf374 1477 .long_name = NULL_IF_CONFIG_SMALL("Huffyuv FFmpeg variant"),
f37b9768 1478};
f544a5fc 1479#endif