annotate huffyuv.c @ 1930:01d6dc162ace libavcodec

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