annotate huffyuv.c @ 1548:dd544554ed42 libavcodec

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