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