Statistics
| Branch: | Revision:

ffmpeg / libavcodec / huffyuv.c @ ab35de18

History | View | Annotate | Download (36.3 KB)

1 11f18faf Michael Niedermayer
/*
2
 * huffyuv codec for libavcodec
3
 *
4 aaa1e4cd Michael Niedermayer
 * Copyright (c) 2002-2003 Michael Niedermayer <michaelni@gmx.at>
5 11f18faf Michael Niedermayer
 *
6
 * This library is free software; you can redistribute it and/or
7
 * modify it under the terms of the GNU Lesser General Public
8
 * License as published by the Free Software Foundation; either
9
 * version 2 of the License, or (at your option) any later version.
10
 *
11
 * This library is distributed in the hope that it will be useful,
12
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14
 * Lesser General Public License for more details.
15
 *
16
 * You should have received a copy of the GNU Lesser General Public
17
 * License along with this library; if not, write to the Free Software
18
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
19
 *
20
 * see http://www.pcisys.net/~melanson/codecs/huffyuv.txt for a description of
21
 * the algorithm used 
22
 */
23 983e3246 Michael Niedermayer
 
24
/**
25
 * @file huffyuv.c
26
 * huffyuv codec for libavcodec.
27
 */
28 11f18faf Michael Niedermayer
29
#include "common.h"
30
#include "avcodec.h"
31
#include "dsputil.h"
32
33
#define VLC_BITS 11
34 1e491e29 Michael Niedermayer
35 11f18faf Michael Niedermayer
typedef enum Predictor{
36
    LEFT= 0,
37
    PLANE,
38
    MEDIAN,
39
} Predictor;
40
 
41
typedef struct HYuvContext{
42
    AVCodecContext *avctx;
43
    Predictor predictor;
44
    GetBitContext gb;
45
    PutBitContext pb;
46
    int interlaced;
47
    int decorrelate;
48
    int bitstream_bpp;
49
    int version;
50
    int yuy2;                               //use yuy2 instead of 422P
51
    int bgr32;                              //use bgr32 instead of bgr24
52
    int width, height;
53
    int flags;
54
    int picture_number;
55 7c5ab7b8 Michael Niedermayer
    int last_slice_end;
56 7674347b Michael Niedermayer
    uint8_t __align8 temp[3][2560];
57 11f18faf Michael Niedermayer
    uint64_t stats[3][256];
58
    uint8_t len[3][256];
59
    uint32_t bits[3][256];
60
    VLC vlc[3];
61 492cd3a9 Michael Niedermayer
    AVFrame picture;
62 11f18faf Michael Niedermayer
    uint8_t __align8 bitstream_buffer[1024*1024*3]; //FIXME dynamic alloc or some other solution
63
    DSPContext dsp; 
64
}HYuvContext;
65
66 24def10e Zdenek Kabelac
static const unsigned char classic_shift_luma[] = {
67 676b385c Michael Niedermayer
  34,36,35,69,135,232,9,16,10,24,11,23,12,16,13,10,14,8,15,8,
68
  16,8,17,20,16,10,207,206,205,236,11,8,10,21,9,23,8,8,199,70,
69
  69,68, 0
70
};
71
72 24def10e Zdenek Kabelac
static const unsigned char classic_shift_chroma[] = {
73 676b385c Michael Niedermayer
  66,36,37,38,39,40,41,75,76,77,110,239,144,81,82,83,84,85,118,183,
74
  56,57,88,89,56,89,154,57,58,57,26,141,57,56,58,57,58,57,184,119,
75
  214,245,116,83,82,49,80,79,78,77,44,75,41,40,39,38,37,36,34, 0
76
};
77
78 24def10e Zdenek Kabelac
static const unsigned char classic_add_luma[256] = {
79 676b385c Michael Niedermayer
    3,  9,  5, 12, 10, 35, 32, 29, 27, 50, 48, 45, 44, 41, 39, 37,
80
   73, 70, 68, 65, 64, 61, 58, 56, 53, 50, 49, 46, 44, 41, 38, 36,
81
   68, 65, 63, 61, 58, 55, 53, 51, 48, 46, 45, 43, 41, 39, 38, 36,
82
   35, 33, 32, 30, 29, 27, 26, 25, 48, 47, 46, 44, 43, 41, 40, 39,
83
   37, 36, 35, 34, 32, 31, 30, 28, 27, 26, 24, 23, 22, 20, 19, 37,
84
   35, 34, 33, 31, 30, 29, 27, 26, 24, 23, 21, 20, 18, 17, 15, 29,
85
   27, 26, 24, 22, 21, 19, 17, 16, 14, 26, 25, 23, 21, 19, 18, 16,
86
   15, 27, 25, 23, 21, 19, 17, 16, 14, 26, 25, 23, 21, 18, 17, 14,
87
   12, 17, 19, 13,  4,  9,  2, 11,  1,  7,  8,  0, 16,  3, 14,  6,
88
   12, 10,  5, 15, 18, 11, 10, 13, 15, 16, 19, 20, 22, 24, 27, 15,
89
   18, 20, 22, 24, 26, 14, 17, 20, 22, 24, 27, 15, 18, 20, 23, 25,
90
   28, 16, 19, 22, 25, 28, 32, 36, 21, 25, 29, 33, 38, 42, 45, 49,
91
   28, 31, 34, 37, 40, 42, 44, 47, 49, 50, 52, 54, 56, 57, 59, 60,
92
   62, 64, 66, 67, 69, 35, 37, 39, 40, 42, 43, 45, 47, 48, 51, 52,
93
   54, 55, 57, 59, 60, 62, 63, 66, 67, 69, 71, 72, 38, 40, 42, 43,
94
   46, 47, 49, 51, 26, 28, 30, 31, 33, 34, 18, 19, 11, 13,  7,  8,
95
};
96
97 24def10e Zdenek Kabelac
static const unsigned char classic_add_chroma[256] = {
98 676b385c Michael Niedermayer
    3,  1,  2,  2,  2,  2,  3,  3,  7,  5,  7,  5,  8,  6, 11,  9,
99
    7, 13, 11, 10,  9,  8,  7,  5,  9,  7,  6,  4,  7,  5,  8,  7,
100
   11,  8, 13, 11, 19, 15, 22, 23, 20, 33, 32, 28, 27, 29, 51, 77,
101
   43, 45, 76, 81, 46, 82, 75, 55, 56,144, 58, 80, 60, 74,147, 63,
102
  143, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
103
   80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 27, 30, 21, 22,
104
   17, 14,  5,  6,100, 54, 47, 50, 51, 53,106,107,108,109,110,111,
105
  112,113,114,115,  4,117,118, 92, 94,121,122,  3,124,103,  2,  1,
106
    0,129,130,131,120,119,126,125,136,137,138,139,140,141,142,134,
107
  135,132,133,104, 64,101, 62, 57,102, 95, 93, 59, 61, 28, 97, 96,
108
   52, 49, 48, 29, 32, 25, 24, 46, 23, 98, 45, 44, 43, 20, 42, 41,
109
   19, 18, 99, 40, 15, 39, 38, 16, 13, 12, 11, 37, 10,  9,  8, 36,
110
    7,128,127,105,123,116, 35, 34, 33,145, 31, 79, 42,146, 78, 26,
111
   83, 48, 49, 50, 44, 47, 26, 31, 30, 18, 17, 19, 21, 24, 25, 13,
112
   14, 16, 17, 18, 20, 21, 12, 14, 15,  9, 10,  6,  9,  6,  5,  8,
113
    6, 12,  8, 10,  7,  9,  6,  4,  6,  2,  2,  3,  3,  3,  3,  2,
114
};
115
116 11f18faf Michael Niedermayer
static inline int add_left_prediction(uint8_t *dst, uint8_t *src, int w, int acc){
117
    int i;
118
119
    for(i=0; i<w-1; i++){
120
        acc+= src[i];
121
        dst[i]= acc;
122
        i++;
123
        acc+= src[i];
124
        dst[i]= acc;
125
    }
126
127
    for(; i<w; i++){
128
        acc+= src[i];
129
        dst[i]= acc;
130
    }
131
132
    return acc;
133
}
134
135
static inline void add_median_prediction(uint8_t *dst, uint8_t *src1, uint8_t *diff, int w, int *left, int *left_top){
136
    int i;
137
    uint8_t l, lt;
138
139
    l= *left;
140
    lt= *left_top;
141
142
    for(i=0; i<w; i++){
143
        l= mid_pred(l, src1[i], (l + src1[i] - lt)&0xFF) + diff[i];
144
        lt= src1[i];
145
        dst[i]= l;
146
    }    
147
148
    *left= l;
149
    *left_top= lt;
150
}
151 5fd74135 Michael Niedermayer
152 11f18faf Michael Niedermayer
static inline void add_left_prediction_bgr32(uint8_t *dst, uint8_t *src, int w, int *red, int *green, int *blue){
153
    int i;
154
    int r,g,b;
155
    r= *red;
156
    g= *green;
157
    b= *blue;
158
159
    for(i=0; i<w; i++){
160
        b+= src[4*i+0];
161
        g+= src[4*i+1];
162
        r+= src[4*i+2];
163
        
164
        dst[4*i+0]= b;
165
        dst[4*i+1]= g;
166
        dst[4*i+2]= r;
167
    }
168
169
    *red= r;
170
    *green= g;
171
    *blue= b;
172
}
173
174 7c5ab7b8 Michael Niedermayer
static inline int sub_left_prediction(HYuvContext *s, uint8_t *dst, uint8_t *src, int w, int left){
175 11f18faf Michael Niedermayer
    int i;
176 7c5ab7b8 Michael Niedermayer
    if(w<32){
177
        for(i=0; i<w; i++){
178
            const int temp= src[i];
179
            dst[i]= temp - left;
180
            left= temp;
181
        }
182
        return left;
183
    }else{
184
        for(i=0; i<16; i++){
185
            const int temp= src[i];
186
            dst[i]= temp - left;
187
            left= temp;
188
        }
189
        s->dsp.diff_bytes(dst+16, src+16, src+15, w-16);
190
        return src[w-1];
191 11f18faf Michael Niedermayer
    }
192
}
193 2a250222 Michael Niedermayer
194 11f18faf Michael Niedermayer
static void read_len_table(uint8_t *dst, GetBitContext *gb){
195
    int i, val, repeat;
196
  
197
    for(i=0; i<256;){
198
        repeat= get_bits(gb, 3);
199
        val   = get_bits(gb, 5);
200
        if(repeat==0)
201
            repeat= get_bits(gb, 8);
202
//printf("%d %d\n", val, repeat);
203
        while (repeat--)
204
            dst[i++] = val;
205
    }
206
}
207
208
static int generate_bits_table(uint32_t *dst, uint8_t *len_table){
209
    int len, index;
210
    uint32_t bits=0;
211
212
    for(len=32; len>0; len--){
213
        for(index=0; index<256; index++){
214 14b74d38 Michael Niedermayer
            if(len_table[index]==len)
215
                dst[index]= bits++;
216 11f18faf Michael Niedermayer
        }
217 14b74d38 Michael Niedermayer
        if(bits & 1){
218 9b879566 Michel Bardiaux
            av_log(NULL, AV_LOG_ERROR, "Error generating huffman table\n");
219 14b74d38 Michael Niedermayer
            return -1;
220
        }
221
        bits >>= 1;
222 11f18faf Michael Niedermayer
    }
223
    return 0;
224
}
225
226
static void generate_len_table(uint8_t *dst, uint64_t *stats, int size){
227
    uint64_t counts[2*size];
228
    int up[2*size];
229
    int offset, i, next;
230
    
231
    for(offset=1; ; offset<<=1){
232
        for(i=0; i<size; i++){
233
            counts[i]= stats[i] + offset - 1;
234
        }
235
        
236
        for(next=size; next<size*2; next++){
237
            uint64_t min1, min2;
238
            int min1_i, min2_i;
239
            
240
            min1=min2= INT64_MAX;
241
            min1_i= min2_i=-1;
242
            
243
            for(i=0; i<next; i++){
244
                if(min2 > counts[i]){
245
                    if(min1 > counts[i]){
246
                        min2= min1;
247
                        min2_i= min1_i;
248
                        min1= counts[i];
249
                        min1_i= i;
250
                    }else{
251
                        min2= counts[i];
252
                        min2_i= i;
253
                    }
254
                }
255
            }
256
            
257
            if(min2==INT64_MAX) break;
258
            
259
            counts[next]= min1 + min2;
260
            counts[min1_i]=
261 0626afe9 Michael Niedermayer
            counts[min2_i]= INT64_MAX;
262 11f18faf Michael Niedermayer
            up[min1_i]=
263
            up[min2_i]= next;
264
            up[next]= -1;
265
        }
266
        
267
        for(i=0; i<size; i++){
268
            int len;
269
            int index=i;
270
            
271
            for(len=0; up[index] != -1; len++)
272
                index= up[index];
273
                
274
            if(len > 32) break;
275
            
276
            dst[i]= len;
277
        }
278
        if(i==size) break;
279
    }
280
}
281
282
static int read_huffman_tables(HYuvContext *s, uint8_t *src, int length){
283
    GetBitContext gb;
284
    int i;
285
    
286 68f593b4 Michael Niedermayer
    init_get_bits(&gb, src, length*8);
287 11f18faf Michael Niedermayer
    
288
    for(i=0; i<3; i++){
289
        read_len_table(s->len[i], &gb);
290
        
291
        if(generate_bits_table(s->bits[i], s->len[i])<0){
292
            return -1;
293
        }
294
#if 0
295
for(j=0; j<256; j++){
296
printf("%6X, %2d,  %3d\n", s->bits[i][j], s->len[i][j], j);
297
}
298
#endif
299
        init_vlc(&s->vlc[i], VLC_BITS, 256, s->len[i], 1, 1, s->bits[i], 4, 4);
300
    }
301
    
302
    return 0;
303
}
304
305
static int read_old_huffman_tables(HYuvContext *s){
306 676b385c Michael Niedermayer
#if 1
307 11f18faf Michael Niedermayer
    GetBitContext gb;
308
    int i;
309
310 68f593b4 Michael Niedermayer
    init_get_bits(&gb, classic_shift_luma, sizeof(classic_shift_luma)*8);
311 11f18faf Michael Niedermayer
    read_len_table(s->len[0], &gb);
312 68f593b4 Michael Niedermayer
    init_get_bits(&gb, classic_shift_chroma, sizeof(classic_shift_chroma)*8);
313 11f18faf Michael Niedermayer
    read_len_table(s->len[1], &gb);
314
    
315
    for(i=0; i<256; i++) s->bits[0][i] = classic_add_luma  [i];
316
    for(i=0; i<256; i++) s->bits[1][i] = classic_add_chroma[i];
317
318
    if(s->bitstream_bpp >= 24){
319
        memcpy(s->bits[1], s->bits[0], 256*sizeof(uint32_t));
320
        memcpy(s->len[1] , s->len [0], 256*sizeof(uint8_t));
321
    }
322
    memcpy(s->bits[2], s->bits[1], 256*sizeof(uint32_t));
323
    memcpy(s->len[2] , s->len [1], 256*sizeof(uint8_t));
324
    
325
    for(i=0; i<3; i++)
326
        init_vlc(&s->vlc[i], VLC_BITS, 256, s->len[i], 1, 1, s->bits[i], 4, 4);
327
    
328
    return 0;
329
#else
330
    fprintf(stderr, "v1 huffyuv is not supported \n");
331
    return -1;
332
#endif
333
}
334
335
static int decode_init(AVCodecContext *avctx)
336
{
337
    HYuvContext *s = avctx->priv_data;
338 1e491e29 Michael Niedermayer
    int width, height;
339 11f18faf Michael Niedermayer
340
    s->avctx= avctx;
341
    s->flags= avctx->flags;
342
        
343 1d98dca3 Michael Niedermayer
    dsputil_init(&s->dsp, avctx);
344 11f18faf Michael Niedermayer
    
345
    width= s->width= avctx->width;
346
    height= s->height= avctx->height;
347 492cd3a9 Michael Niedermayer
    avctx->coded_frame= &s->picture;
348 1e491e29 Michael Niedermayer
349 11f18faf Michael Niedermayer
s->bgr32=1;
350
    assert(width && height);
351
//if(avctx->extradata)
352
//  printf("extradata:%X, extradata_size:%d\n", *(uint32_t*)avctx->extradata, avctx->extradata_size);
353
    if(avctx->extradata_size){
354 152ba68c Michael Niedermayer
        if((avctx->bits_per_sample&7) && avctx->bits_per_sample != 12)
355 11f18faf Michael Niedermayer
            s->version=1; // do such files exist at all?
356
        else
357
            s->version=2;
358
    }else
359
        s->version=0;
360
    
361
    if(s->version==2){
362
        int method;
363
364
        method= ((uint8_t*)avctx->extradata)[0];
365
        s->decorrelate= method&64 ? 1 : 0;
366
        s->predictor= method&63;
367
        s->bitstream_bpp= ((uint8_t*)avctx->extradata)[1];
368
        if(s->bitstream_bpp==0) 
369
            s->bitstream_bpp= avctx->bits_per_sample&~7;
370
            
371
        if(read_huffman_tables(s, ((uint8_t*)avctx->extradata)+4, avctx->extradata_size) < 0)
372
            return -1;
373
    }else{
374
        switch(avctx->bits_per_sample&7){
375
        case 1:
376
            s->predictor= LEFT;
377
            s->decorrelate= 0;
378
            break;
379
        case 2:
380
            s->predictor= LEFT;
381
            s->decorrelate= 1;
382
            break;
383
        case 3:
384
            s->predictor= PLANE;
385
            s->decorrelate= avctx->bits_per_sample >= 24;
386
            break;
387
        case 4:
388
            s->predictor= MEDIAN;
389
            s->decorrelate= 0;
390
            break;
391
        default:
392
            s->predictor= LEFT; //OLD
393
            s->decorrelate= 0;
394
            break;
395
        }
396
        s->bitstream_bpp= avctx->bits_per_sample & ~7;
397
        
398
        if(read_old_huffman_tables(s) < 0)
399
            return -1;
400
    }
401
    
402
    s->interlaced= height > 288;
403
    
404
    switch(s->bitstream_bpp){
405
    case 12:
406
        avctx->pix_fmt = PIX_FMT_YUV420P;
407
        break;
408
    case 16:
409
        if(s->yuy2){
410
            avctx->pix_fmt = PIX_FMT_YUV422;
411
        }else{
412
            avctx->pix_fmt = PIX_FMT_YUV422P;
413
        }
414
        break;
415
    case 24:
416
    case 32:
417
        if(s->bgr32){
418 0b2612b1 Fabrice Bellard
            avctx->pix_fmt = PIX_FMT_RGBA32;
419 11f18faf Michael Niedermayer
        }else{
420
            avctx->pix_fmt = PIX_FMT_BGR24;
421
        }
422
        break;
423
    default:
424
        assert(0);
425
    }
426
    
427
//    printf("pred:%d bpp:%d hbpp:%d il:%d\n", s->predictor, s->bitstream_bpp, avctx->bits_per_sample, s->interlaced);
428
    
429
    return 0;
430
}
431
432
static void store_table(HYuvContext *s, uint8_t *len){
433
    int i;
434
    int index= s->avctx->extradata_size;
435
436
    for(i=0; i<256;){
437
        int val= len[i];
438 a003ee9a Michael Niedermayer
        int repeat=0;
439 11f18faf Michael Niedermayer
        
440 a003ee9a Michael Niedermayer
        for(; i<256 && len[i]==val && repeat<255; i++)
441
            repeat++;
442 11f18faf Michael Niedermayer
        
443 a003ee9a Michael Niedermayer
        assert(val < 32 && val >0 && repeat<256 && repeat>0);
444 11f18faf Michael Niedermayer
        if(repeat>7){
445
            ((uint8_t*)s->avctx->extradata)[index++]= val;
446
            ((uint8_t*)s->avctx->extradata)[index++]= repeat;
447
        }else{
448
            ((uint8_t*)s->avctx->extradata)[index++]= val | (repeat<<5);
449
        }
450
    }
451
    
452
    s->avctx->extradata_size= index;
453
}
454
455
static int encode_init(AVCodecContext *avctx)
456
{
457
    HYuvContext *s = avctx->priv_data;
458
    int i, j, width, height;
459
460
    s->avctx= avctx;
461
    s->flags= avctx->flags;
462
        
463 1d98dca3 Michael Niedermayer
    dsputil_init(&s->dsp, avctx);
464 11f18faf Michael Niedermayer
    
465
    width= s->width= avctx->width;
466
    height= s->height= avctx->height;
467
    
468
    assert(width && height);
469
    
470 8c812d73 Michael Niedermayer
    avctx->extradata= av_mallocz(1024*30);
471
    avctx->stats_out= av_mallocz(1024*30);
472 11f18faf Michael Niedermayer
    s->version=2;
473
    
474 492cd3a9 Michael Niedermayer
    avctx->coded_frame= &s->picture;
475 1e491e29 Michael Niedermayer
    
476 11f18faf Michael Niedermayer
    switch(avctx->pix_fmt){
477 152ba68c Michael Niedermayer
    case PIX_FMT_YUV420P:
478
        s->bitstream_bpp= 12;
479
        break;
480 11f18faf Michael Niedermayer
    case PIX_FMT_YUV422P:
481
        s->bitstream_bpp= 16;
482
        break;
483
    default:
484 9b879566 Michel Bardiaux
        av_log(avctx, AV_LOG_ERROR, "format not supported\n");
485 11f18faf Michael Niedermayer
        return -1;
486
    }
487
    avctx->bits_per_sample= s->bitstream_bpp;
488
    s->decorrelate= s->bitstream_bpp >= 24;
489
    s->predictor= avctx->prediction_method;
490
    
491
    ((uint8_t*)avctx->extradata)[0]= s->predictor;
492
    ((uint8_t*)avctx->extradata)[1]= s->bitstream_bpp;
493
    ((uint8_t*)avctx->extradata)[2]=
494
    ((uint8_t*)avctx->extradata)[3]= 0;
495
    s->avctx->extradata_size= 4;
496
    
497
    if(avctx->stats_in){
498
        char *p= avctx->stats_in;
499
    
500
        for(i=0; i<3; i++)
501
            for(j=0; j<256; j++)
502
                s->stats[i][j]= 1;
503
504
        for(;;){
505
            for(i=0; i<3; i++){
506
                char *next;
507
508
                for(j=0; j<256; j++){
509
                    s->stats[i][j]+= strtol(p, &next, 0);
510
                    if(next==p) return -1;
511
                    p=next;
512
                }        
513
            }
514
            if(p[0]==0 || p[1]==0 || p[2]==0) break;
515
        }
516
    }else{
517
        for(i=0; i<3; i++)
518
            for(j=0; j<256; j++){
519
                int d= FFMIN(j, 256-j);
520
                
521
                s->stats[i][j]= 100000000/(d+1);
522
            }
523
    }
524
    
525
    for(i=0; i<3; i++){
526
        generate_len_table(s->len[i], s->stats[i], 256);
527
528
        if(generate_bits_table(s->bits[i], s->len[i])<0){
529
            return -1;
530
        }
531
        
532
        store_table(s, s->len[i]);
533
    }
534
535
    for(i=0; i<3; i++)
536
        for(j=0; j<256; j++)
537
            s->stats[i][j]= 0;
538
    
539
    s->interlaced= height > 288;
540 5fd74135 Michael Niedermayer
541 11f18faf Michael Niedermayer
//    printf("pred:%d bpp:%d hbpp:%d il:%d\n", s->predictor, s->bitstream_bpp, avctx->bits_per_sample, s->interlaced);
542 5fd74135 Michael Niedermayer
543 11f18faf Michael Niedermayer
    s->picture_number=0;
544 5fd74135 Michael Niedermayer
545 11f18faf Michael Niedermayer
    return 0;
546
}
547
548
static void decode_422_bitstream(HYuvContext *s, int count){
549
    int i;
550 5fd74135 Michael Niedermayer
551 11f18faf Michael Niedermayer
    count/=2;
552
    
553
    for(i=0; i<count; i++){
554
        s->temp[0][2*i  ]= get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3); 
555
        s->temp[1][  i  ]= get_vlc2(&s->gb, s->vlc[1].table, VLC_BITS, 3); 
556
        s->temp[0][2*i+1]= get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3); 
557
        s->temp[2][  i  ]= get_vlc2(&s->gb, s->vlc[2].table, VLC_BITS, 3); 
558
    }
559
}
560
561 152ba68c Michael Niedermayer
static void decode_gray_bitstream(HYuvContext *s, int count){
562
    int i;
563
    
564
    count/=2;
565
    
566
    for(i=0; i<count; i++){
567
        s->temp[0][2*i  ]= get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3); 
568
        s->temp[0][2*i+1]= get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3); 
569
    }
570
}
571
572 11f18faf Michael Niedermayer
static void encode_422_bitstream(HYuvContext *s, int count){
573
    int i;
574
    
575
    count/=2;
576
    if(s->flags&CODEC_FLAG_PASS1){
577
        for(i=0; i<count; i++){
578
            s->stats[0][ s->temp[0][2*i  ] ]++;
579
            s->stats[1][ s->temp[1][  i  ] ]++;
580
            s->stats[0][ s->temp[0][2*i+1] ]++;
581
            s->stats[2][ s->temp[2][  i  ] ]++;
582
        }
583
    }else{
584
        for(i=0; i<count; i++){
585
            put_bits(&s->pb, s->len[0][ s->temp[0][2*i  ] ], s->bits[0][ s->temp[0][2*i  ] ]);
586
            put_bits(&s->pb, s->len[1][ s->temp[1][  i  ] ], s->bits[1][ s->temp[1][  i  ] ]);
587
            put_bits(&s->pb, s->len[0][ s->temp[0][2*i+1] ], s->bits[0][ s->temp[0][2*i+1] ]);
588
            put_bits(&s->pb, s->len[2][ s->temp[2][  i  ] ], s->bits[2][ s->temp[2][  i  ] ]);
589
        }
590
    }
591
}
592
593 152ba68c Michael Niedermayer
static void encode_gray_bitstream(HYuvContext *s, int count){
594
    int i;
595
    
596
    count/=2;
597
    if(s->flags&CODEC_FLAG_PASS1){
598
        for(i=0; i<count; i++){
599
            s->stats[0][ s->temp[0][2*i  ] ]++;
600
            s->stats[0][ s->temp[0][2*i+1] ]++;
601
        }
602
    }else{
603
        for(i=0; i<count; i++){
604
            put_bits(&s->pb, s->len[0][ s->temp[0][2*i  ] ], s->bits[0][ s->temp[0][2*i  ] ]);
605
            put_bits(&s->pb, s->len[0][ s->temp[0][2*i+1] ], s->bits[0][ s->temp[0][2*i+1] ]);
606
        }
607
    }
608
}
609
610 11f18faf Michael Niedermayer
static void decode_bgr_bitstream(HYuvContext *s, int count){
611
    int i;
612 5fd74135 Michael Niedermayer
613 11f18faf Michael Niedermayer
    if(s->decorrelate){
614
        if(s->bitstream_bpp==24){
615
            for(i=0; i<count; i++){
616
                s->temp[0][4*i+1]= get_vlc2(&s->gb, s->vlc[1].table, VLC_BITS, 3); 
617
                s->temp[0][4*i  ]= get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3) + s->temp[0][4*i+1];
618
                s->temp[0][4*i+2]= get_vlc2(&s->gb, s->vlc[2].table, VLC_BITS, 3) + s->temp[0][4*i+1];
619
            }
620
        }else{
621
            for(i=0; i<count; i++){
622
                s->temp[0][4*i+1]= get_vlc2(&s->gb, s->vlc[1].table, VLC_BITS, 3); 
623
                s->temp[0][4*i  ]= get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3) + s->temp[0][4*i+1];
624
                s->temp[0][4*i+2]= get_vlc2(&s->gb, s->vlc[2].table, VLC_BITS, 3) + s->temp[0][4*i+1]; 
625
                                   get_vlc2(&s->gb, s->vlc[2].table, VLC_BITS, 3); //?!
626
            }
627
        }
628
    }else{
629
        if(s->bitstream_bpp==24){
630
            for(i=0; i<count; i++){
631
                s->temp[0][4*i  ]= get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3);
632
                s->temp[0][4*i+1]= get_vlc2(&s->gb, s->vlc[1].table, VLC_BITS, 3); 
633
                s->temp[0][4*i+2]= get_vlc2(&s->gb, s->vlc[2].table, VLC_BITS, 3); 
634
            }
635
        }else{
636
            for(i=0; i<count; i++){
637
                s->temp[0][4*i  ]= get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3);
638
                s->temp[0][4*i+1]= get_vlc2(&s->gb, s->vlc[1].table, VLC_BITS, 3); 
639
                s->temp[0][4*i+2]= get_vlc2(&s->gb, s->vlc[2].table, VLC_BITS, 3); 
640
                                   get_vlc2(&s->gb, s->vlc[2].table, VLC_BITS, 3); //?!
641
            }
642
        }
643
    }
644
}
645
646 7c5ab7b8 Michael Niedermayer
static void draw_slice(HYuvContext *s, int y){
647
    int h, cy;
648 7a06ff14 Michael Niedermayer
    int offset[4];
649 7c5ab7b8 Michael Niedermayer
    
650
    if(s->avctx->draw_horiz_band==NULL) 
651
        return;
652
        
653
    h= y - s->last_slice_end;
654
    y -= h;
655
    
656
    if(s->bitstream_bpp==12){
657
        cy= y>>1;
658
    }else{
659
        cy= y;
660
    }
661 7a06ff14 Michael Niedermayer
662
    offset[0] = s->picture.linesize[0]*y;
663
    offset[1] = s->picture.linesize[1]*cy;
664
    offset[2] = s->picture.linesize[2]*cy;
665
    offset[3] = 0;
666 7c5ab7b8 Michael Niedermayer
    emms_c();
667
668 3bb07d61 Michael Niedermayer
    s->avctx->draw_horiz_band(s->avctx, &s->picture, offset, y, 3, h);
669 7c5ab7b8 Michael Niedermayer
    
670
    s->last_slice_end= y + h;
671
}
672
673 11f18faf Michael Niedermayer
static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, uint8_t *buf, int buf_size){
674
    HYuvContext *s = avctx->priv_data;
675
    const int width= s->width;
676
    const int width2= s->width>>1;
677
    const int height= s->height;
678 22f3e8be Michael Niedermayer
    int fake_ystride, fake_ustride, fake_vstride;
679 492cd3a9 Michael Niedermayer
    AVFrame * const p= &s->picture;
680 11f18faf Michael Niedermayer
681 492cd3a9 Michael Niedermayer
    AVFrame *picture = data;
682 11f18faf Michael Niedermayer
683
    /* no supplementary picture */
684
    if (buf_size == 0)
685
        return 0;
686
687 3d2e8cce Michael Niedermayer
    s->dsp.bswap_buf((uint32_t*)s->bitstream_buffer, (uint32_t*)buf, buf_size/4);
688 11f18faf Michael Niedermayer
    
689 68f593b4 Michael Niedermayer
    init_get_bits(&s->gb, s->bitstream_buffer, buf_size*8);
690 22f3e8be Michael Niedermayer
691 e20c4069 Michael Niedermayer
    if(p->data[0])
692
        avctx->release_buffer(avctx, p);
693
694 1e491e29 Michael Niedermayer
    p->reference= 0;
695
    if(avctx->get_buffer(avctx, p) < 0){
696 9b879566 Michel Bardiaux
        av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
697 1e491e29 Michael Niedermayer
        return -1;
698 22f3e8be Michael Niedermayer
    }
699 1e491e29 Michael Niedermayer
700
    fake_ystride= s->interlaced ? p->linesize[0]*2  : p->linesize[0];
701
    fake_ustride= s->interlaced ? p->linesize[1]*2  : p->linesize[1];
702
    fake_vstride= s->interlaced ? p->linesize[2]*2  : p->linesize[2];
703 7c5ab7b8 Michael Niedermayer
    
704
    s->last_slice_end= 0;
705 22f3e8be Michael Niedermayer
        
706 11f18faf Michael Niedermayer
    if(s->bitstream_bpp<24){
707 152ba68c Michael Niedermayer
        int y, cy;
708 11f18faf Michael Niedermayer
        int lefty, leftu, leftv;
709
        int lefttopy, lefttopu, lefttopv;
710
        
711
        if(s->yuy2){
712 1e491e29 Michael Niedermayer
            p->data[0][3]= get_bits(&s->gb, 8);
713
            p->data[0][2]= get_bits(&s->gb, 8);
714
            p->data[0][1]= get_bits(&s->gb, 8);
715
            p->data[0][0]= get_bits(&s->gb, 8);
716 11f18faf Michael Niedermayer
            
717 9b879566 Michel Bardiaux
            av_log(avctx, AV_LOG_ERROR, "YUY2 output isnt implemenetd yet\n");
718 11f18faf Michael Niedermayer
            return -1;
719
        }else{
720
        
721 1e491e29 Michael Niedermayer
            leftv= p->data[2][0]= get_bits(&s->gb, 8);
722
            lefty= p->data[0][1]= get_bits(&s->gb, 8);
723
            leftu= p->data[1][0]= get_bits(&s->gb, 8);
724
                   p->data[0][0]= get_bits(&s->gb, 8);
725 11f18faf Michael Niedermayer
        
726
            switch(s->predictor){
727
            case LEFT:
728
            case PLANE:
729
                decode_422_bitstream(s, width-2);
730 1e491e29 Michael Niedermayer
                lefty= add_left_prediction(p->data[0] + 2, s->temp[0], width-2, lefty);
731 11f18faf Michael Niedermayer
                if(!(s->flags&CODEC_FLAG_GRAY)){
732 1e491e29 Michael Niedermayer
                    leftu= add_left_prediction(p->data[1] + 1, s->temp[1], width2-1, leftu);
733
                    leftv= add_left_prediction(p->data[2] + 1, s->temp[2], width2-1, leftv);
734 11f18faf Michael Niedermayer
                }
735
736 152ba68c Michael Niedermayer
                for(cy=y=1; y<s->height; y++,cy++){
737 11f18faf Michael Niedermayer
                    uint8_t *ydst, *udst, *vdst;
738 152ba68c Michael Niedermayer
                    
739
                    if(s->bitstream_bpp==12){
740
                        decode_gray_bitstream(s, width);
741
                    
742 1e491e29 Michael Niedermayer
                        ydst= p->data[0] + p->linesize[0]*y;
743 152ba68c Michael Niedermayer
744
                        lefty= add_left_prediction(ydst, s->temp[0], width, lefty);
745
                        if(s->predictor == PLANE){
746
                            if(y>s->interlaced)
747
                                s->dsp.add_bytes(ydst, ydst - fake_ystride, width);
748
                        }
749
                        y++;
750
                        if(y>=s->height) break;
751
                    }
752 11f18faf Michael Niedermayer
                    
753 7c5ab7b8 Michael Niedermayer
                    draw_slice(s, y);
754
                    
755 1e491e29 Michael Niedermayer
                    ydst= p->data[0] + p->linesize[0]*y;
756
                    udst= p->data[1] + p->linesize[1]*cy;
757
                    vdst= p->data[2] + p->linesize[2]*cy;
758 152ba68c Michael Niedermayer
                    
759
                    decode_422_bitstream(s, width);
760 11f18faf Michael Niedermayer
                    lefty= add_left_prediction(ydst, s->temp[0], width, lefty);
761
                    if(!(s->flags&CODEC_FLAG_GRAY)){
762
                        leftu= add_left_prediction(udst, s->temp[1], width2, leftu);
763
                        leftv= add_left_prediction(vdst, s->temp[2], width2, leftv);
764
                    }
765
                    if(s->predictor == PLANE){
766 152ba68c Michael Niedermayer
                        if(cy>s->interlaced){
767 11f18faf Michael Niedermayer
                            s->dsp.add_bytes(ydst, ydst - fake_ystride, width);
768
                            if(!(s->flags&CODEC_FLAG_GRAY)){
769
                                s->dsp.add_bytes(udst, udst - fake_ustride, width2);
770
                                s->dsp.add_bytes(vdst, vdst - fake_vstride, width2);
771
                            }
772
                        }
773
                    }
774
                }
775 7c5ab7b8 Michael Niedermayer
                draw_slice(s, height);
776
                
777 11f18faf Michael Niedermayer
                break;
778
            case MEDIAN:
779
                /* first line except first 2 pixels is left predicted */
780
                decode_422_bitstream(s, width-2);
781 1e491e29 Michael Niedermayer
                lefty= add_left_prediction(p->data[0] + 2, s->temp[0], width-2, lefty);
782 11f18faf Michael Niedermayer
                if(!(s->flags&CODEC_FLAG_GRAY)){
783 1e491e29 Michael Niedermayer
                    leftu= add_left_prediction(p->data[1] + 1, s->temp[1], width2-1, leftu);
784
                    leftv= add_left_prediction(p->data[2] + 1, s->temp[2], width2-1, leftv);
785 11f18faf Michael Niedermayer
                }
786
                
787 152ba68c Michael Niedermayer
                cy=y=1;
788 11f18faf Michael Niedermayer
                
789
                /* second line is left predicted for interlaced case */
790
                if(s->interlaced){
791
                    decode_422_bitstream(s, width);
792 1e491e29 Michael Niedermayer
                    lefty= add_left_prediction(p->data[0] + p->linesize[0], s->temp[0], width, lefty);
793 11f18faf Michael Niedermayer
                    if(!(s->flags&CODEC_FLAG_GRAY)){
794 1e491e29 Michael Niedermayer
                        leftu= add_left_prediction(p->data[1] + p->linesize[2], s->temp[1], width2, leftu);
795
                        leftv= add_left_prediction(p->data[2] + p->linesize[1], s->temp[2], width2, leftv);
796 11f18faf Michael Niedermayer
                    }
797 152ba68c Michael Niedermayer
                    y++; cy++;
798 11f18faf Michael Niedermayer
                }
799
800
                /* next 4 pixels are left predicted too */
801
                decode_422_bitstream(s, 4);
802 1e491e29 Michael Niedermayer
                lefty= add_left_prediction(p->data[0] + fake_ystride, s->temp[0], 4, lefty);
803 11f18faf Michael Niedermayer
                if(!(s->flags&CODEC_FLAG_GRAY)){
804 1e491e29 Michael Niedermayer
                    leftu= add_left_prediction(p->data[1] + fake_ustride, s->temp[1], 2, leftu);
805
                    leftv= add_left_prediction(p->data[2] + fake_vstride, s->temp[2], 2, leftv);
806 11f18faf Michael Niedermayer
                }
807
808
                /* next line except the first 4 pixels is median predicted */
809 1e491e29 Michael Niedermayer
                lefttopy= p->data[0][3];
810 11f18faf Michael Niedermayer
                decode_422_bitstream(s, width-4);
811 1e491e29 Michael Niedermayer
                add_median_prediction(p->data[0] + fake_ystride+4, p->data[0]+4, s->temp[0], width-4, &lefty, &lefttopy);
812 11f18faf Michael Niedermayer
                if(!(s->flags&CODEC_FLAG_GRAY)){
813 1e491e29 Michael Niedermayer
                    lefttopu= p->data[1][1];
814
                    lefttopv= p->data[2][1];
815
                    add_median_prediction(p->data[1] + fake_ustride+2, p->data[1]+2, s->temp[1], width2-2, &leftu, &lefttopu);
816
                    add_median_prediction(p->data[2] + fake_vstride+2, p->data[2]+2, s->temp[2], width2-2, &leftv, &lefttopv);
817 11f18faf Michael Niedermayer
                }
818 152ba68c Michael Niedermayer
                y++; cy++;
819
                
820
                for(; y<height; y++,cy++){
821 11f18faf Michael Niedermayer
                    uint8_t *ydst, *udst, *vdst;
822 152ba68c Michael Niedermayer
823
                    if(s->bitstream_bpp==12){
824
                        while(2*cy > y){
825
                            decode_gray_bitstream(s, width);
826 1e491e29 Michael Niedermayer
                            ydst= p->data[0] + p->linesize[0]*y;
827 152ba68c Michael Niedermayer
                            add_median_prediction(ydst, ydst - fake_ystride, s->temp[0], width, &lefty, &lefttopy);
828
                            y++;
829
                        }
830
                        if(y>=height) break;
831
                    }
832 7c5ab7b8 Michael Niedermayer
                    draw_slice(s, y);
833 152ba68c Michael Niedermayer
834 11f18faf Michael Niedermayer
                    decode_422_bitstream(s, width);
835 152ba68c Michael Niedermayer
836 1e491e29 Michael Niedermayer
                    ydst= p->data[0] + p->linesize[0]*y;
837
                    udst= p->data[1] + p->linesize[1]*cy;
838
                    vdst= p->data[2] + p->linesize[2]*cy;
839 11f18faf Michael Niedermayer
840
                    add_median_prediction(ydst, ydst - fake_ystride, s->temp[0], width, &lefty, &lefttopy);
841
                    if(!(s->flags&CODEC_FLAG_GRAY)){
842
                        add_median_prediction(udst, udst - fake_ustride, s->temp[1], width2, &leftu, &lefttopu);
843
                        add_median_prediction(vdst, vdst - fake_vstride, s->temp[2], width2, &leftv, &lefttopv);
844
                    }
845
                }
846 7c5ab7b8 Michael Niedermayer
847
                draw_slice(s, height);
848 11f18faf Michael Niedermayer
                break;
849
            }
850
        }
851
    }else{
852
        int y;
853
        int leftr, leftg, leftb;
854 1e491e29 Michael Niedermayer
        const int last_line= (height-1)*p->linesize[0];
855 11f18faf Michael Niedermayer
        
856
        if(s->bitstream_bpp==32){
857 1e491e29 Michael Niedermayer
                   p->data[0][last_line+3]= get_bits(&s->gb, 8);
858
            leftr= p->data[0][last_line+2]= get_bits(&s->gb, 8);
859
            leftg= p->data[0][last_line+1]= get_bits(&s->gb, 8);
860
            leftb= p->data[0][last_line+0]= get_bits(&s->gb, 8);
861 11f18faf Michael Niedermayer
        }else{
862 1e491e29 Michael Niedermayer
            leftr= p->data[0][last_line+2]= get_bits(&s->gb, 8);
863
            leftg= p->data[0][last_line+1]= get_bits(&s->gb, 8);
864
            leftb= p->data[0][last_line+0]= get_bits(&s->gb, 8);
865 11f18faf Michael Niedermayer
            skip_bits(&s->gb, 8);
866
        }
867
        
868
        if(s->bgr32){
869
            switch(s->predictor){
870
            case LEFT:
871
            case PLANE:
872
                decode_bgr_bitstream(s, width-1);
873 1e491e29 Michael Niedermayer
                add_left_prediction_bgr32(p->data[0] + last_line+4, s->temp[0], width-1, &leftr, &leftg, &leftb);
874 11f18faf Michael Niedermayer
875
                for(y=s->height-2; y>=0; y--){ //yes its stored upside down
876
                    decode_bgr_bitstream(s, width);
877
                    
878 1e491e29 Michael Niedermayer
                    add_left_prediction_bgr32(p->data[0] + p->linesize[0]*y, s->temp[0], width, &leftr, &leftg, &leftb);
879 11f18faf Michael Niedermayer
                    if(s->predictor == PLANE){
880
                        if((y&s->interlaced)==0){
881 1e491e29 Michael Niedermayer
                            s->dsp.add_bytes(p->data[0] + p->linesize[0]*y, 
882
                                             p->data[0] + p->linesize[0]*y + fake_ystride, fake_ystride);
883 11f18faf Michael Niedermayer
                        }
884
                    }
885
                }
886 7c5ab7b8 Michael Niedermayer
                draw_slice(s, height); // just 1 large slice as this isnt possible in reverse order
887 11f18faf Michael Niedermayer
                break;
888
            default:
889 9b879566 Michel Bardiaux
                av_log(avctx, AV_LOG_ERROR, "prediction type not supported!\n");
890 11f18faf Michael Niedermayer
            }
891
        }else{
892
893 9b879566 Michel Bardiaux
            av_log(avctx, AV_LOG_ERROR, "BGR24 output isnt implemenetd yet\n");
894 11f18faf Michael Niedermayer
            return -1;
895
        }
896
    }
897
    emms_c();
898
    
899 1e491e29 Michael Niedermayer
    *picture= *p;
900 492cd3a9 Michael Niedermayer
    *data_size = sizeof(AVFrame);
901 11f18faf Michael Niedermayer
    
902 8c031d1c Michael Niedermayer
    return (get_bits_count(&s->gb)+31)/32*4;
903 11f18faf Michael Niedermayer
}
904
905
static int decode_end(AVCodecContext *avctx)
906
{
907
    HYuvContext *s = avctx->priv_data;
908
    int i;
909
    
910
    for(i=0; i<3; i++){
911
        free_vlc(&s->vlc[i]);
912
    }
913 1e491e29 Michael Niedermayer
914 11f18faf Michael Niedermayer
    return 0;
915
}
916
917
static int encode_frame(AVCodecContext *avctx, unsigned char *buf, int buf_size, void *data){
918
    HYuvContext *s = avctx->priv_data;
919 492cd3a9 Michael Niedermayer
    AVFrame *pict = data;
920 11f18faf Michael Niedermayer
    const int width= s->width;
921
    const int width2= s->width>>1;
922
    const int height= s->height;
923
    const int fake_ystride= s->interlaced ? pict->linesize[0]*2  : pict->linesize[0];
924
    const int fake_ustride= s->interlaced ? pict->linesize[1]*2  : pict->linesize[1];
925
    const int fake_vstride= s->interlaced ? pict->linesize[2]*2  : pict->linesize[2];
926 492cd3a9 Michael Niedermayer
    AVFrame * const p= &s->picture;
927 11f18faf Michael Niedermayer
    int i, size;
928
929 ed7debda Alex Beregszaszi
    init_put_bits(&s->pb, buf, buf_size);
930 11f18faf Michael Niedermayer
    
931 1e491e29 Michael Niedermayer
    *p = *pict;
932 aaa1e4cd Michael Niedermayer
    p->pict_type= FF_I_TYPE;
933
    p->key_frame= 1;
934 11f18faf Michael Niedermayer
    
935 152ba68c Michael Niedermayer
    if(avctx->pix_fmt == PIX_FMT_YUV422P || avctx->pix_fmt == PIX_FMT_YUV420P){
936
        int lefty, leftu, leftv, y, cy;
937 11f18faf Michael Niedermayer
938 1e491e29 Michael Niedermayer
        put_bits(&s->pb, 8, leftv= p->data[2][0]);
939
        put_bits(&s->pb, 8, lefty= p->data[0][1]);
940
        put_bits(&s->pb, 8, leftu= p->data[1][0]);
941
        put_bits(&s->pb, 8,        p->data[0][0]);
942 11f18faf Michael Niedermayer
        
943 1e491e29 Michael Niedermayer
        lefty= sub_left_prediction(s, s->temp[0], p->data[0]+2, width-2 , lefty);
944
        leftu= sub_left_prediction(s, s->temp[1], p->data[1]+1, width2-1, leftu);
945
        leftv= sub_left_prediction(s, s->temp[2], p->data[2]+1, width2-1, leftv);
946 11f18faf Michael Niedermayer
        
947
        encode_422_bitstream(s, width-2);
948
        
949
        if(s->predictor==MEDIAN){
950
            int lefttopy, lefttopu, lefttopv;
951 152ba68c Michael Niedermayer
            cy=y=1;
952 11f18faf Michael Niedermayer
            if(s->interlaced){
953 1e491e29 Michael Niedermayer
                lefty= sub_left_prediction(s, s->temp[0], p->data[0]+p->linesize[0], width , lefty);
954
                leftu= sub_left_prediction(s, s->temp[1], p->data[1]+p->linesize[1], width2, leftu);
955
                leftv= sub_left_prediction(s, s->temp[2], p->data[2]+p->linesize[2], width2, leftv);
956 11f18faf Michael Niedermayer
        
957
                encode_422_bitstream(s, width);
958 152ba68c Michael Niedermayer
                y++; cy++;
959 11f18faf Michael Niedermayer
            }
960
            
961 1e491e29 Michael Niedermayer
            lefty= sub_left_prediction(s, s->temp[0], p->data[0]+fake_ystride, 4, lefty);
962
            leftu= sub_left_prediction(s, s->temp[1], p->data[1]+fake_ystride, 2, leftu);
963
            leftv= sub_left_prediction(s, s->temp[2], p->data[2]+fake_ystride, 2, leftv);
964 11f18faf Michael Niedermayer
        
965
            encode_422_bitstream(s, 4);
966 152ba68c Michael Niedermayer
967 1e491e29 Michael Niedermayer
            lefttopy= p->data[0][3];
968
            lefttopu= p->data[1][1];
969
            lefttopv= p->data[2][1];
970 84705403 Michael Niedermayer
            s->dsp.sub_hfyu_median_prediction(s->temp[0], p->data[0]+4, p->data[0] + fake_ystride+4, width-4 , &lefty, &lefttopy);
971
            s->dsp.sub_hfyu_median_prediction(s->temp[1], p->data[1]+2, p->data[1] + fake_ustride+2, width2-2, &leftu, &lefttopu);
972
            s->dsp.sub_hfyu_median_prediction(s->temp[2], p->data[2]+2, p->data[2] + fake_vstride+2, width2-2, &leftv, &lefttopv);
973 11f18faf Michael Niedermayer
            encode_422_bitstream(s, width-4);
974 152ba68c Michael Niedermayer
            y++; cy++;
975 11f18faf Michael Niedermayer
976 152ba68c Michael Niedermayer
            for(; y<height; y++,cy++){
977 11f18faf Michael Niedermayer
                uint8_t *ydst, *udst, *vdst;
978
                    
979 152ba68c Michael Niedermayer
                if(s->bitstream_bpp==12){
980
                    while(2*cy > y){
981 1e491e29 Michael Niedermayer
                        ydst= p->data[0] + p->linesize[0]*y;
982 84705403 Michael Niedermayer
                        s->dsp.sub_hfyu_median_prediction(s->temp[0], ydst - fake_ystride, ydst, width , &lefty, &lefttopy);
983 152ba68c Michael Niedermayer
                        encode_gray_bitstream(s, width);
984
                        y++;
985
                    }
986
                    if(y>=height) break;
987
                }
988 1e491e29 Michael Niedermayer
                ydst= p->data[0] + p->linesize[0]*y;
989
                udst= p->data[1] + p->linesize[1]*cy;
990
                vdst= p->data[2] + p->linesize[2]*cy;
991 11f18faf Michael Niedermayer
992 84705403 Michael Niedermayer
                s->dsp.sub_hfyu_median_prediction(s->temp[0], ydst - fake_ystride, ydst, width , &lefty, &lefttopy);
993
                s->dsp.sub_hfyu_median_prediction(s->temp[1], udst - fake_ustride, udst, width2, &leftu, &lefttopu);
994
                s->dsp.sub_hfyu_median_prediction(s->temp[2], vdst - fake_vstride, vdst, width2, &leftv, &lefttopv);
995 11f18faf Michael Niedermayer
996
                encode_422_bitstream(s, width);
997
            }
998
        }else{
999 152ba68c Michael Niedermayer
            for(cy=y=1; y<height; y++,cy++){
1000 11f18faf Michael Niedermayer
                uint8_t *ydst, *udst, *vdst;
1001 152ba68c Michael Niedermayer
                
1002
                /* encode a luma only line & y++ */
1003
                if(s->bitstream_bpp==12){
1004 1e491e29 Michael Niedermayer
                    ydst= p->data[0] + p->linesize[0]*y;
1005 152ba68c Michael Niedermayer
1006
                    if(s->predictor == PLANE && s->interlaced < y){
1007 7c5ab7b8 Michael Niedermayer
                        s->dsp.diff_bytes(s->temp[1], ydst, ydst - fake_ystride, width);
1008 152ba68c Michael Niedermayer
1009 7c5ab7b8 Michael Niedermayer
                        lefty= sub_left_prediction(s, s->temp[0], s->temp[1], width , lefty);
1010 152ba68c Michael Niedermayer
                    }else{
1011 7c5ab7b8 Michael Niedermayer
                        lefty= sub_left_prediction(s, s->temp[0], ydst, width , lefty);
1012 152ba68c Michael Niedermayer
                    }
1013
                    encode_gray_bitstream(s, width);
1014
                    y++;
1015
                    if(y>=height) break;
1016
                }
1017
                
1018 1e491e29 Michael Niedermayer
                ydst= p->data[0] + p->linesize[0]*y;
1019
                udst= p->data[1] + p->linesize[1]*cy;
1020
                vdst= p->data[2] + p->linesize[2]*cy;
1021 11f18faf Michael Niedermayer
1022 152ba68c Michael Niedermayer
                if(s->predictor == PLANE && s->interlaced < cy){
1023 7c5ab7b8 Michael Niedermayer
                    s->dsp.diff_bytes(s->temp[1], ydst, ydst - fake_ystride, width);
1024
                    s->dsp.diff_bytes(s->temp[2], udst, udst - fake_ustride, width2);
1025 8c812d73 Michael Niedermayer
                    s->dsp.diff_bytes(s->temp[2] + 1250, vdst, vdst - fake_vstride, width2);
1026 11f18faf Michael Niedermayer
1027 7c5ab7b8 Michael Niedermayer
                    lefty= sub_left_prediction(s, s->temp[0], s->temp[1], width , lefty);
1028
                    leftu= sub_left_prediction(s, s->temp[1], s->temp[2], width2, leftu);
1029 8c812d73 Michael Niedermayer
                    leftv= sub_left_prediction(s, s->temp[2], s->temp[2] + 1250, width2, leftv);
1030 11f18faf Michael Niedermayer
                }else{
1031 7c5ab7b8 Michael Niedermayer
                    lefty= sub_left_prediction(s, s->temp[0], ydst, width , lefty);
1032
                    leftu= sub_left_prediction(s, s->temp[1], udst, width2, leftu);
1033
                    leftv= sub_left_prediction(s, s->temp[2], vdst, width2, leftv);
1034 11f18faf Michael Niedermayer
                }
1035
1036
                encode_422_bitstream(s, width);
1037
            }
1038
        }        
1039
    }else{
1040 9b879566 Michel Bardiaux
        av_log(avctx, AV_LOG_ERROR, "Format not supported!\n");
1041 11f18faf Michael Niedermayer
    }
1042
    emms_c();
1043
    
1044 fe455f33 Alex Beregszaszi
    size= (put_bits_count(&s->pb)+31)/32;
1045 11f18faf Michael Niedermayer
    
1046
    if((s->flags&CODEC_FLAG_PASS1) && (s->picture_number&31)==0){
1047
        int j;
1048
        char *p= avctx->stats_out;
1049
        for(i=0; i<3; i++){
1050
            for(j=0; j<256; j++){
1051 4cfbf61b Falk H├╝ffner
                sprintf(p, "%llu ", s->stats[i][j]);
1052 11f18faf Michael Niedermayer
                p+= strlen(p);
1053
                s->stats[i][j]= 0;
1054
            }
1055
            sprintf(p, "\n");
1056
            p++;
1057
        }
1058
    }else{
1059 152ba68c Michael Niedermayer
        flush_put_bits(&s->pb);
1060 3d2e8cce Michael Niedermayer
        s->dsp.bswap_buf((uint32_t*)buf, (uint32_t*)buf, size);
1061 11f18faf Michael Niedermayer
    }
1062
    
1063
    s->picture_number++;
1064 1e491e29 Michael Niedermayer
1065 11f18faf Michael Niedermayer
    return size*4;
1066
}
1067
1068
static int encode_end(AVCodecContext *avctx)
1069
{
1070
//    HYuvContext *s = avctx->priv_data;
1071
1072
    av_freep(&avctx->extradata);
1073
    av_freep(&avctx->stats_out);
1074
    
1075
    return 0;
1076
}
1077
1078 5d4ce457 Zdenek Kabelac
static const AVOption huffyuv_options[] =
1079
{
1080
    AVOPTION_CODEC_INT("prediction_method", "prediction_method", prediction_method, 0, 2, 0),
1081
    AVOPTION_END()
1082
};
1083
1084 11f18faf Michael Niedermayer
AVCodec huffyuv_decoder = {
1085
    "huffyuv",
1086
    CODEC_TYPE_VIDEO,
1087
    CODEC_ID_HUFFYUV,
1088
    sizeof(HYuvContext),
1089
    decode_init,
1090
    NULL,
1091
    decode_end,
1092
    decode_frame,
1093 7c5ab7b8 Michael Niedermayer
    CODEC_CAP_DR1 | CODEC_CAP_DRAW_HORIZ_BAND,
1094 11f18faf Michael Niedermayer
    NULL
1095
};
1096
1097 5fd74135 Michael Niedermayer
#ifdef CONFIG_ENCODERS
1098
1099 11f18faf Michael Niedermayer
AVCodec huffyuv_encoder = {
1100
    "huffyuv",
1101
    CODEC_TYPE_VIDEO,
1102
    CODEC_ID_HUFFYUV,
1103
    sizeof(HYuvContext),
1104
    encode_init,
1105
    encode_frame,
1106
    encode_end,
1107 5d4ce457 Zdenek Kabelac
    .options = huffyuv_options,
1108 11f18faf Michael Niedermayer
};
1109 5fd74135 Michael Niedermayer
1110 aea22133 Zdenek Kabelac
#endif //CONFIG_ENCODERS