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