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