annotate huffyuv.c @ 2122:503496800167 libavcodec

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