Statistics
| Branch: | Revision:

ffmpeg / libavcodec / huffyuv.c @ 186447f8

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