annotate h263.c @ 285:39b78867b71f libavcodec

dont return -1 if mpeg4 scalability ...
author michaelni
date Sat, 23 Mar 2002 13:00:08 +0000
parents d94f9f58a2c5
children 91f7c38f5f37
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
rev   line source
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1 /*
986e461dc072 Initial revision
glantau
parents:
diff changeset
2 * H263/MPEG4 backend for ffmpeg encoder and decoder
986e461dc072 Initial revision
glantau
parents:
diff changeset
3 * Copyright (c) 2000,2001 Gerard Lantau.
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
4 * H263+ support.
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
5 * Copyright (c) 2001 Juan J. Sierralta P.
986e461dc072 Initial revision
glantau
parents:
diff changeset
6 *
986e461dc072 Initial revision
glantau
parents:
diff changeset
7 * This program is free software; you can redistribute it and/or modify
986e461dc072 Initial revision
glantau
parents:
diff changeset
8 * it under the terms of the GNU General Public License as published by
986e461dc072 Initial revision
glantau
parents:
diff changeset
9 * the Free Software Foundation; either version 2 of the License, or
986e461dc072 Initial revision
glantau
parents:
diff changeset
10 * (at your option) any later version.
986e461dc072 Initial revision
glantau
parents:
diff changeset
11 *
986e461dc072 Initial revision
glantau
parents:
diff changeset
12 * This program is distributed in the hope that it will be useful,
986e461dc072 Initial revision
glantau
parents:
diff changeset
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
986e461dc072 Initial revision
glantau
parents:
diff changeset
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
986e461dc072 Initial revision
glantau
parents:
diff changeset
15 * GNU General Public License for more details.
986e461dc072 Initial revision
glantau
parents:
diff changeset
16 *
986e461dc072 Initial revision
glantau
parents:
diff changeset
17 * You should have received a copy of the GNU General Public License
986e461dc072 Initial revision
glantau
parents:
diff changeset
18 * along with this program; if not, write to the Free Software
986e461dc072 Initial revision
glantau
parents:
diff changeset
19 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
277
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
20 *
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
21 * ac prediction encoding by Michael Niedermayer <michaelni@gmx.at>
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
22 */
986e461dc072 Initial revision
glantau
parents:
diff changeset
23 #include "common.h"
986e461dc072 Initial revision
glantau
parents:
diff changeset
24 #include "dsputil.h"
986e461dc072 Initial revision
glantau
parents:
diff changeset
25 #include "avcodec.h"
986e461dc072 Initial revision
glantau
parents:
diff changeset
26 #include "mpegvideo.h"
986e461dc072 Initial revision
glantau
parents:
diff changeset
27 #include "h263data.h"
986e461dc072 Initial revision
glantau
parents:
diff changeset
28 #include "mpeg4data.h"
986e461dc072 Initial revision
glantau
parents:
diff changeset
29
255
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
30 //rounded divison & shift
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
31 #define RDIV(a,b) ((a) > 0 ? ((a)+((b)>>1))/(b) : ((a)-((b)>>1))/(b))
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
32 #define RSHIFT(a,b) ((a) > 0 ? ((a) + (1<<((b)-1)))>>(b) : ((a) + (1<<((b)-1))-1)>>(b))
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
33 #define ABS(a) (((a)>=0)?(a):(-(a)))
255
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
34
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
35 static void h263_encode_block(MpegEncContext * s, DCTELEM * block,
986e461dc072 Initial revision
glantau
parents:
diff changeset
36 int n);
986e461dc072 Initial revision
glantau
parents:
diff changeset
37 static void h263_encode_motion(MpegEncContext * s, int val);
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
38 static void h263p_encode_umotion(MpegEncContext * s, int val);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
39 static void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block,
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
40 int n, int dc, UINT8 *scan_table);
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
41 static int h263_decode_motion(MpegEncContext * s, int pred, int fcode);
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
42 static int h263p_decode_umotion(MpegEncContext * s, int pred);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
43 static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
986e461dc072 Initial revision
glantau
parents:
diff changeset
44 int n, int coded);
986e461dc072 Initial revision
glantau
parents:
diff changeset
45 static int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
986e461dc072 Initial revision
glantau
parents:
diff changeset
46 int n, int coded);
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
47 static inline int mpeg4_pred_dc(MpegEncContext * s, int n, UINT16 **dc_val_ptr, int *dir_ptr);
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
48 static void mpeg4_inv_pred_ac(MpegEncContext * s, INT16 *block, int n,
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
49 int dir);
277
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
50 extern UINT32 inverse[256];
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
51
277
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
52 static UINT16 mv_penalty[MAX_FCODE][MAX_MV*2+1];
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
53 static UINT8 fcode_tab[MAX_MV*2+1];
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
54
986e461dc072 Initial revision
glantau
parents:
diff changeset
55 int h263_get_picture_format(int width, int height)
986e461dc072 Initial revision
glantau
parents:
diff changeset
56 {
986e461dc072 Initial revision
glantau
parents:
diff changeset
57 int format;
986e461dc072 Initial revision
glantau
parents:
diff changeset
58
986e461dc072 Initial revision
glantau
parents:
diff changeset
59 if (width == 128 && height == 96)
986e461dc072 Initial revision
glantau
parents:
diff changeset
60 format = 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
61 else if (width == 176 && height == 144)
986e461dc072 Initial revision
glantau
parents:
diff changeset
62 format = 2;
986e461dc072 Initial revision
glantau
parents:
diff changeset
63 else if (width == 352 && height == 288)
986e461dc072 Initial revision
glantau
parents:
diff changeset
64 format = 3;
986e461dc072 Initial revision
glantau
parents:
diff changeset
65 else if (width == 704 && height == 576)
986e461dc072 Initial revision
glantau
parents:
diff changeset
66 format = 4;
986e461dc072 Initial revision
glantau
parents:
diff changeset
67 else if (width == 1408 && height == 1152)
986e461dc072 Initial revision
glantau
parents:
diff changeset
68 format = 5;
986e461dc072 Initial revision
glantau
parents:
diff changeset
69 else
986e461dc072 Initial revision
glantau
parents:
diff changeset
70 format = 7;
986e461dc072 Initial revision
glantau
parents:
diff changeset
71 return format;
986e461dc072 Initial revision
glantau
parents:
diff changeset
72 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
73
986e461dc072 Initial revision
glantau
parents:
diff changeset
74 void h263_encode_picture_header(MpegEncContext * s, int picture_number)
986e461dc072 Initial revision
glantau
parents:
diff changeset
75 {
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
76 int format;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
77
986e461dc072 Initial revision
glantau
parents:
diff changeset
78 align_put_bits(&s->pb);
231
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
79
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
80 /* Update the pointer to last GOB */
234
5fc0c3af3fe4 alternative bitstream writer (disabled by default, uncomment #define ALT_BISTREAM_WRITER in common.h if u want to try it)
michaelni
parents: 231
diff changeset
81 s->ptr_lastgob = pbBufPtr(&s->pb);
231
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
82 s->gob_number = 0;
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
83
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
84 put_bits(&s->pb, 22, 0x20); /* PSC */
241
4bb6289eff93 avoid overflow of picturenumber*fps*10000
michaelni
parents: 234
diff changeset
85 put_bits(&s->pb, 8, (((INT64)s->picture_number * 30 * FRAME_RATE_BASE) /
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
86 s->frame_rate) & 0xff);
986e461dc072 Initial revision
glantau
parents:
diff changeset
87
986e461dc072 Initial revision
glantau
parents:
diff changeset
88 put_bits(&s->pb, 1, 1); /* marker */
986e461dc072 Initial revision
glantau
parents:
diff changeset
89 put_bits(&s->pb, 1, 0); /* h263 id */
986e461dc072 Initial revision
glantau
parents:
diff changeset
90 put_bits(&s->pb, 1, 0); /* split screen off */
986e461dc072 Initial revision
glantau
parents:
diff changeset
91 put_bits(&s->pb, 1, 0); /* camera off */
986e461dc072 Initial revision
glantau
parents:
diff changeset
92 put_bits(&s->pb, 1, 0); /* freeze picture release off */
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
93
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
94 format = h263_get_picture_format(s->width, s->height);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
95 if (!s->h263_plus) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
96 /* H.263v1 */
986e461dc072 Initial revision
glantau
parents:
diff changeset
97 put_bits(&s->pb, 3, format);
986e461dc072 Initial revision
glantau
parents:
diff changeset
98 put_bits(&s->pb, 1, (s->pict_type == P_TYPE));
986e461dc072 Initial revision
glantau
parents:
diff changeset
99 /* By now UMV IS DISABLED ON H.263v1, since the restrictions
986e461dc072 Initial revision
glantau
parents:
diff changeset
100 of H.263v1 UMV implies to check the predicted MV after
986e461dc072 Initial revision
glantau
parents:
diff changeset
101 calculation of the current MB to see if we're on the limits */
986e461dc072 Initial revision
glantau
parents:
diff changeset
102 put_bits(&s->pb, 1, 0); /* unrestricted motion vector: off */
986e461dc072 Initial revision
glantau
parents:
diff changeset
103 put_bits(&s->pb, 1, 0); /* SAC: off */
986e461dc072 Initial revision
glantau
parents:
diff changeset
104 put_bits(&s->pb, 1, 0); /* advanced prediction mode: off */
986e461dc072 Initial revision
glantau
parents:
diff changeset
105 put_bits(&s->pb, 1, 0); /* not PB frame */
986e461dc072 Initial revision
glantau
parents:
diff changeset
106 put_bits(&s->pb, 5, s->qscale);
986e461dc072 Initial revision
glantau
parents:
diff changeset
107 put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */
986e461dc072 Initial revision
glantau
parents:
diff changeset
108 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
109 /* H.263v2 */
986e461dc072 Initial revision
glantau
parents:
diff changeset
110 /* H.263 Plus PTYPE */
986e461dc072 Initial revision
glantau
parents:
diff changeset
111 put_bits(&s->pb, 3, 7);
986e461dc072 Initial revision
glantau
parents:
diff changeset
112 put_bits(&s->pb,3,1); /* Update Full Extended PTYPE */
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
113 if (format == 7)
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
114 put_bits(&s->pb,3,6); /* Custom Source Format */
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
115 else
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
116 put_bits(&s->pb, 3, format);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
117
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
118 put_bits(&s->pb,1,0); /* Custom PCF: off */
79
82e579c37bc3 Moved some H.263+ variables to MpegEncContext to be thread-safe.
pulento
parents: 78
diff changeset
119 s->umvplus = (s->pict_type == P_TYPE) && s->unrestricted_mv;
82e579c37bc3 Moved some H.263+ variables to MpegEncContext to be thread-safe.
pulento
parents: 78
diff changeset
120 put_bits(&s->pb, 1, s->umvplus); /* Unrestricted Motion Vector */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
121 put_bits(&s->pb,1,0); /* SAC: off */
986e461dc072 Initial revision
glantau
parents:
diff changeset
122 put_bits(&s->pb,1,0); /* Advanced Prediction Mode: off */
986e461dc072 Initial revision
glantau
parents:
diff changeset
123 put_bits(&s->pb,1,0); /* Advanced Intra Coding: off */
986e461dc072 Initial revision
glantau
parents:
diff changeset
124 put_bits(&s->pb,1,0); /* Deblocking Filter: off */
986e461dc072 Initial revision
glantau
parents:
diff changeset
125 put_bits(&s->pb,1,0); /* Slice Structured: off */
986e461dc072 Initial revision
glantau
parents:
diff changeset
126 put_bits(&s->pb,1,0); /* Reference Picture Selection: off */
986e461dc072 Initial revision
glantau
parents:
diff changeset
127 put_bits(&s->pb,1,0); /* Independent Segment Decoding: off */
986e461dc072 Initial revision
glantau
parents:
diff changeset
128 put_bits(&s->pb,1,0); /* Alternative Inter VLC: off */
986e461dc072 Initial revision
glantau
parents:
diff changeset
129 put_bits(&s->pb,1,0); /* Modified Quantization: off */
986e461dc072 Initial revision
glantau
parents:
diff changeset
130 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
986e461dc072 Initial revision
glantau
parents:
diff changeset
131 put_bits(&s->pb,3,0); /* Reserved */
986e461dc072 Initial revision
glantau
parents:
diff changeset
132
986e461dc072 Initial revision
glantau
parents:
diff changeset
133 put_bits(&s->pb, 3, s->pict_type == P_TYPE);
986e461dc072 Initial revision
glantau
parents:
diff changeset
134
986e461dc072 Initial revision
glantau
parents:
diff changeset
135 put_bits(&s->pb,1,0); /* Reference Picture Resampling: off */
986e461dc072 Initial revision
glantau
parents:
diff changeset
136 put_bits(&s->pb,1,0); /* Reduced-Resolution Update: off */
986e461dc072 Initial revision
glantau
parents:
diff changeset
137 put_bits(&s->pb,1,0); /* Rounding Type */
986e461dc072 Initial revision
glantau
parents:
diff changeset
138 put_bits(&s->pb,2,0); /* Reserved */
986e461dc072 Initial revision
glantau
parents:
diff changeset
139 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
986e461dc072 Initial revision
glantau
parents:
diff changeset
140
986e461dc072 Initial revision
glantau
parents:
diff changeset
141 /* This should be here if PLUSPTYPE */
986e461dc072 Initial revision
glantau
parents:
diff changeset
142 put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */
986e461dc072 Initial revision
glantau
parents:
diff changeset
143
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
144 if (format == 7) {
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
145 /* Custom Picture Format (CPFMT) */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
146
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
147 put_bits(&s->pb,4,2); /* Aspect ratio: CIF 12:11 (4:3) picture */
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
148 put_bits(&s->pb,9,(s->width >> 2) - 1);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
149 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
150 put_bits(&s->pb,9,(s->height >> 2));
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
151 }
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
152
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
153 /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
79
82e579c37bc3 Moved some H.263+ variables to MpegEncContext to be thread-safe.
pulento
parents: 78
diff changeset
154 if (s->umvplus)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
155 put_bits(&s->pb,1,1); /* Limited according tables of Annex D */
986e461dc072 Initial revision
glantau
parents:
diff changeset
156 put_bits(&s->pb, 5, s->qscale);
986e461dc072 Initial revision
glantau
parents:
diff changeset
157 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
158
986e461dc072 Initial revision
glantau
parents:
diff changeset
159 put_bits(&s->pb, 1, 0); /* no PEI */
986e461dc072 Initial revision
glantau
parents:
diff changeset
160 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
161
162
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
162 int h263_encode_gob_header(MpegEncContext * s, int mb_line)
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
163 {
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
164 int pdif=0;
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
165
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
166 /* Check to see if we need to put a new GBSC */
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
167 /* for RTP packetization */
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
168 if (s->rtp_mode) {
234
5fc0c3af3fe4 alternative bitstream writer (disabled by default, uncomment #define ALT_BISTREAM_WRITER in common.h if u want to try it)
michaelni
parents: 231
diff changeset
169 pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;
162
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
170 if (pdif >= s->rtp_payload_size) {
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
171 /* Bad luck, packet must be cut before */
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
172 align_put_bits(&s->pb);
231
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
173 flush_put_bits(&s->pb);
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
174 /* Call the RTP callback to send the last GOB */
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
175 if (s->rtp_callback) {
234
5fc0c3af3fe4 alternative bitstream writer (disabled by default, uncomment #define ALT_BISTREAM_WRITER in common.h if u want to try it)
michaelni
parents: 231
diff changeset
176 pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;
231
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
177 s->rtp_callback(s->ptr_lastgob, pdif, s->gob_number);
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
178 }
234
5fc0c3af3fe4 alternative bitstream writer (disabled by default, uncomment #define ALT_BISTREAM_WRITER in common.h if u want to try it)
michaelni
parents: 231
diff changeset
179 s->ptr_lastgob = pbBufPtr(&s->pb);
162
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
180 put_bits(&s->pb, 17, 1); /* GBSC */
231
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
181 s->gob_number = mb_line / s->gob_index;
162
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
182 put_bits(&s->pb, 5, s->gob_number); /* GN */
231
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
183 put_bits(&s->pb, 2, s->pict_type == I_TYPE); /* GFID */
162
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
184 put_bits(&s->pb, 5, s->qscale); /* GQUANT */
231
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
185 //fprintf(stderr,"\nGOB: %2d size: %d", s->gob_number - 1, pdif);
162
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
186 return pdif;
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
187 } else if (pdif + s->mb_line_avgsize >= s->rtp_payload_size) {
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
188 /* Cut the packet before we can't */
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
189 align_put_bits(&s->pb);
231
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
190 flush_put_bits(&s->pb);
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
191 /* Call the RTP callback to send the last GOB */
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
192 if (s->rtp_callback) {
234
5fc0c3af3fe4 alternative bitstream writer (disabled by default, uncomment #define ALT_BISTREAM_WRITER in common.h if u want to try it)
michaelni
parents: 231
diff changeset
193 pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;
231
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
194 s->rtp_callback(s->ptr_lastgob, pdif, s->gob_number);
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
195 }
234
5fc0c3af3fe4 alternative bitstream writer (disabled by default, uncomment #define ALT_BISTREAM_WRITER in common.h if u want to try it)
michaelni
parents: 231
diff changeset
196 s->ptr_lastgob = pbBufPtr(&s->pb);
162
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
197 put_bits(&s->pb, 17, 1); /* GBSC */
231
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
198 s->gob_number = mb_line / s->gob_index;
162
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
199 put_bits(&s->pb, 5, s->gob_number); /* GN */
231
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
200 put_bits(&s->pb, 2, s->pict_type == I_TYPE); /* GFID */
162
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
201 put_bits(&s->pb, 5, s->qscale); /* GQUANT */
231
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
202 //fprintf(stderr,"\nGOB: %2d size: %d", s->gob_number - 1, pdif);
162
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
203 return pdif;
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
204 }
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
205 }
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
206 return 0;
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
207 }
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
208
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
209 static inline int decide_ac_pred(MpegEncContext * s, DCTELEM block[6][64], int dir[6])
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
210 {
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
211 int score0=0, score1=0;
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
212 int i, n;
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
213
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
214 for(n=0; n<6; n++){
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
215 INT16 *ac_val, *ac_val1;
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
216
266
252444e5259b optimization
michaelni
parents: 265
diff changeset
217 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
218 ac_val1= ac_val;
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
219 if(dir[n]){
266
252444e5259b optimization
michaelni
parents: 265
diff changeset
220 ac_val-= s->block_wrap[n]*16;
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
221 for(i=1; i<8; i++){
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
222 const int level= block[n][block_permute_op(i )];
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
223 score0+= ABS(level);
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
224 score1+= ABS(level - ac_val[i+8]);
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
225 ac_val1[i ]= block[n][block_permute_op(i<<3)];
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
226 ac_val1[i+8]= level;
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
227 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
228 }else{
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
229 ac_val-= 16;
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
230 for(i=1; i<8; i++){
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
231 const int level= block[n][block_permute_op(i<<3)];
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
232 score0+= ABS(level);
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
233 score1+= ABS(level - ac_val[i]);
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
234 ac_val1[i ]= level;
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
235 ac_val1[i+8]= block[n][block_permute_op(i )];
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
236 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
237 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
238 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
239
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
240 return score0 > score1 ? 1 : 0;
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
241 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
242
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
243 void mpeg4_encode_mb(MpegEncContext * s,
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
244 DCTELEM block[6][64],
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
245 int motion_x, int motion_y)
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
246 {
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
247 int cbpc, cbpy, i, cbp, pred_x, pred_y;
162
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
248
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
249 // printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
250 if (!s->mb_intra) {
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
251 /* compute cbp */
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
252 cbp = 0;
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
253 for (i = 0; i < 6; i++) {
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
254 if (s->block_last_index[i] >= 0)
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
255 cbp |= 1 << (5 - i);
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
256 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
257 if ((cbp | motion_x | motion_y) == 0) {
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
258 /* skip macroblock */
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
259 put_bits(&s->pb, 1, 1);
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
260 return;
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
261 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
262 put_bits(&s->pb, 1, 0); /* mb coded */
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
263 cbpc = cbp & 3;
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
264 put_bits(&s->pb,
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
265 inter_MCBPC_bits[cbpc],
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
266 inter_MCBPC_code[cbpc]);
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
267 cbpy = cbp >> 2;
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
268 cbpy ^= 0xf;
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
269 put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
270
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
271 /* motion vectors: 16x16 mode only now */
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
272 h263_pred_motion(s, 0, &pred_x, &pred_y);
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
273
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
274 h263_encode_motion(s, motion_x - pred_x);
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
275 h263_encode_motion(s, motion_y - pred_y);
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
276
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
277 /* encode each block */
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
278 for (i = 0; i < 6; i++) {
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
279 mpeg4_encode_block(s, block[i], i, 0, zigzag_direct);
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
280 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
281 } else {
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
282 int dc_diff[6]; //dc values with the dc prediction subtracted
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
283 int dir[6]; //prediction direction
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
284 int zigzag_last_index[6];
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
285 UINT8 *scan_table[6];
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
286
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
287 for(i=0; i<6; i++){
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
288 const int level= block[i][0];
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
289 UINT16 *dc_ptr;
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
290
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
291 dc_diff[i]= level - mpeg4_pred_dc(s, i, &dc_ptr, &dir[i]);
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
292 if (i < 4) {
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
293 *dc_ptr = level * s->y_dc_scale;
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
294 } else {
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
295 *dc_ptr = level * s->c_dc_scale;
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
296 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
297 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
298
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
299 s->ac_pred= decide_ac_pred(s, block, dir);
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
300
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
301 if(s->ac_pred){
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
302 for(i=0; i<6; i++){
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
303 UINT8 *st;
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
304 int last_index;
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
305
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
306 mpeg4_inv_pred_ac(s, block[i], i, dir[i]);
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
307 if (dir[i]==0) st = ff_alternate_vertical_scan; /* left */
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
308 else st = ff_alternate_horizontal_scan; /* top */
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
309
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
310 for(last_index=63; last_index>=0; last_index--) //FIXME optimize
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
311 if(block[i][st[last_index]]) break;
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
312 zigzag_last_index[i]= s->block_last_index[i];
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
313 s->block_last_index[i]= last_index;
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
314 scan_table[i]= st;
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
315 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
316 }else{
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
317 for(i=0; i<6; i++)
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
318 scan_table[i]= zigzag_direct;
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
319 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
320
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
321 /* compute cbp */
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
322 cbp = 0;
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
323 for (i = 0; i < 6; i++) {
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
324 if (s->block_last_index[i] >= 1)
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
325 cbp |= 1 << (5 - i);
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
326 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
327
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
328 cbpc = cbp & 3;
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
329 if (s->pict_type == I_TYPE) {
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
330 put_bits(&s->pb,
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
331 intra_MCBPC_bits[cbpc],
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
332 intra_MCBPC_code[cbpc]);
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
333 } else {
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
334 put_bits(&s->pb, 1, 0); /* mb coded */
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
335 put_bits(&s->pb,
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
336 inter_MCBPC_bits[cbpc + 4],
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
337 inter_MCBPC_code[cbpc + 4]);
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
338 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
339 put_bits(&s->pb, 1, s->ac_pred);
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
340 cbpy = cbp >> 2;
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
341 put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
342
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
343 /* encode each block */
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
344 for (i = 0; i < 6; i++) {
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
345 mpeg4_encode_block(s, block[i], i, dc_diff[i], scan_table[i]);
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
346 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
347
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
348 /* restore ac coeffs & last_index stuff if we messed them up with the prediction */
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
349 if(s->ac_pred){
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
350 for(i=0; i<6; i++){
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
351 int j;
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
352 INT16 *ac_val;
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
353
266
252444e5259b optimization
michaelni
parents: 265
diff changeset
354 ac_val = s->ac_val[0][0] + s->block_index[i] * 16;
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
355
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
356 if(dir[i]){
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
357 for(j=1; j<8; j++)
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
358 block[i][block_permute_op(j )]= ac_val[j+8];
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
359 }else{
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
360 for(j=1; j<8; j++)
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
361 block[i][block_permute_op(j<<3)]= ac_val[j ];
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
362 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
363 s->block_last_index[i]= zigzag_last_index[i];
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
364 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
365 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
366 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
367 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
368
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
369 void h263_encode_mb(MpegEncContext * s,
986e461dc072 Initial revision
glantau
parents:
diff changeset
370 DCTELEM block[6][64],
986e461dc072 Initial revision
glantau
parents:
diff changeset
371 int motion_x, int motion_y)
986e461dc072 Initial revision
glantau
parents:
diff changeset
372 {
986e461dc072 Initial revision
glantau
parents:
diff changeset
373 int cbpc, cbpy, i, cbp, pred_x, pred_y;
162
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
374
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
375 // printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
376 if (!s->mb_intra) {
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
377 /* compute cbp */
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
378 cbp = 0;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
379 for (i = 0; i < 6; i++) {
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
380 if (s->block_last_index[i] >= 0)
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
381 cbp |= 1 << (5 - i);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
382 }
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
383 if ((cbp | motion_x | motion_y) == 0) {
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
384 /* skip macroblock */
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
385 put_bits(&s->pb, 1, 1);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
386 return;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
387 }
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
388 put_bits(&s->pb, 1, 0); /* mb coded */
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
389 cbpc = cbp & 3;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
390 put_bits(&s->pb,
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
391 inter_MCBPC_bits[cbpc],
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
392 inter_MCBPC_code[cbpc]);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
393 cbpy = cbp >> 2;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
394 cbpy ^= 0xf;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
395 put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
396
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
397 /* motion vectors: 16x16 mode only now */
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
398 h263_pred_motion(s, 0, &pred_x, &pred_y);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
399
79
82e579c37bc3 Moved some H.263+ variables to MpegEncContext to be thread-safe.
pulento
parents: 78
diff changeset
400 if (!s->umvplus) {
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
401 h263_encode_motion(s, motion_x - pred_x);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
402 h263_encode_motion(s, motion_y - pred_y);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
403 }
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
404 else {
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
405 h263p_encode_umotion(s, motion_x - pred_x);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
406 h263p_encode_umotion(s, motion_y - pred_y);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
407 if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
408 /* To prevent Start Code emulation */
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
409 put_bits(&s->pb,1,1);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
410 }
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
411 } else {
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
412 /* compute cbp */
986e461dc072 Initial revision
glantau
parents:
diff changeset
413 cbp = 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
414 for (i = 0; i < 6; i++) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
415 if (s->block_last_index[i] >= 1)
986e461dc072 Initial revision
glantau
parents:
diff changeset
416 cbp |= 1 << (5 - i);
986e461dc072 Initial revision
glantau
parents:
diff changeset
417 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
418
986e461dc072 Initial revision
glantau
parents:
diff changeset
419 cbpc = cbp & 3;
986e461dc072 Initial revision
glantau
parents:
diff changeset
420 if (s->pict_type == I_TYPE) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
421 put_bits(&s->pb,
986e461dc072 Initial revision
glantau
parents:
diff changeset
422 intra_MCBPC_bits[cbpc],
986e461dc072 Initial revision
glantau
parents:
diff changeset
423 intra_MCBPC_code[cbpc]);
986e461dc072 Initial revision
glantau
parents:
diff changeset
424 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
425 put_bits(&s->pb, 1, 0); /* mb coded */
986e461dc072 Initial revision
glantau
parents:
diff changeset
426 put_bits(&s->pb,
986e461dc072 Initial revision
glantau
parents:
diff changeset
427 inter_MCBPC_bits[cbpc + 4],
986e461dc072 Initial revision
glantau
parents:
diff changeset
428 inter_MCBPC_code[cbpc + 4]);
986e461dc072 Initial revision
glantau
parents:
diff changeset
429 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
430 if (s->h263_pred) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
431 /* XXX: currently, we do not try to use ac prediction */
986e461dc072 Initial revision
glantau
parents:
diff changeset
432 put_bits(&s->pb, 1, 0); /* no ac prediction */
986e461dc072 Initial revision
glantau
parents:
diff changeset
433 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
434 cbpy = cbp >> 2;
986e461dc072 Initial revision
glantau
parents:
diff changeset
435 put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
986e461dc072 Initial revision
glantau
parents:
diff changeset
436 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
437
986e461dc072 Initial revision
glantau
parents:
diff changeset
438 /* encode each block */
986e461dc072 Initial revision
glantau
parents:
diff changeset
439 if (s->h263_pred) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
440 for (i = 0; i < 6; i++) {
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
441 // mpeg4_encode_block(s, block[i], i);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
442 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
443 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
444 for (i = 0; i < 6; i++) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
445 h263_encode_block(s, block[i], i);
986e461dc072 Initial revision
glantau
parents:
diff changeset
446 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
447 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
448 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
449
249
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
450 void h263_pred_acdc(MpegEncContext * s, INT16 *block, int n)
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
451 {
249
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
452 int x, y, wrap, a, c, pred_dc, scale, i;
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
453 INT16 *dc_val, *ac_val, *ac_val1;
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
454
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
455 /* find prediction */
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
456 if (n < 4) {
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
457 x = 2 * s->mb_x + 1 + (n & 1);
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
458 y = 2 * s->mb_y + 1 + ((n & 2) >> 1);
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
459 wrap = s->mb_width * 2 + 2;
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
460 dc_val = s->dc_val[0];
249
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
461 ac_val = s->ac_val[0][0];
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
462 scale = s->y_dc_scale;
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
463 } else {
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
464 x = s->mb_x + 1;
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
465 y = s->mb_y + 1;
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
466 wrap = s->mb_width + 2;
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
467 dc_val = s->dc_val[n - 4 + 1];
249
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
468 ac_val = s->ac_val[n - 4 + 1][0];
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
469 scale = s->c_dc_scale;
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
470 }
249
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
471
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
472 ac_val += ((y) * wrap + (x)) * 16;
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
473 ac_val1 = ac_val;
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
474
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
475 /* B C
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
476 * A X
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
477 */
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
478 a = dc_val[(x - 1) + (y) * wrap];
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
479 c = dc_val[(x) + (y - 1) * wrap];
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
480
249
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
481 pred_dc = 1024;
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
482 if (s->ac_pred) {
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
483 if (s->h263_aic_dir) {
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
484 /* left prediction */
249
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
485 if (a != 1024) {
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
486 ac_val -= 16;
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
487 for(i=1;i<8;i++) {
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
488 block[block_permute_op(i*8)] += ac_val[i];
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
489 }
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
490 pred_dc = a;
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
491 }
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
492 } else {
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
493 /* top prediction */
249
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
494 if (c != 1024) {
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
495 ac_val -= 16 * wrap;
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
496 for(i=1;i<8;i++) {
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
497 block[block_permute_op(i)] += ac_val[i + 8];
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
498 }
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
499 pred_dc = c;
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
500 }
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
501 }
249
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
502 } else {
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
503 /* just DC prediction */
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
504 if (a != 1024 && c != 1024)
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
505 pred_dc = (a + c) >> 1;
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
506 else if (a != 1024)
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
507 pred_dc = a;
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
508 else
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
509 pred_dc = c;
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
510 }
249
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
511
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
512 /* we assume pred is positive */
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
513 block[0]=block[0]*scale + pred_dc;
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
514
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
515 if (block[0] < 0)
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
516 block[0] = 0;
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
517 else if (!(block[0] & 1))
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
518 block[0]++;
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
519
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
520 /* Update AC/DC tables */
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
521 dc_val[(x) + (y) * wrap] = block[0];
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
522
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
523 /* left copy */
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
524 for(i=1;i<8;i++)
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
525 ac_val1[i] = block[block_permute_op(i * 8)];
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
526 /* top copy */
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
527 for(i=1;i<8;i++)
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
528 ac_val1[8 + i] = block[block_permute_op(i)];
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
529 }
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
530
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
531 INT16 *h263_pred_motion(MpegEncContext * s, int block,
986e461dc072 Initial revision
glantau
parents:
diff changeset
532 int *px, int *py)
986e461dc072 Initial revision
glantau
parents:
diff changeset
533 {
266
252444e5259b optimization
michaelni
parents: 265
diff changeset
534 int xy, wrap;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
535 INT16 *A, *B, *C, *mot_val;
264
28c5c62b1c4c support decoding (with mplayer) of 3 .mp4 files from mphq
michaelni
parents: 263
diff changeset
536 static const int off[4]= {2, 1, 1, -1};
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
537
266
252444e5259b optimization
michaelni
parents: 265
diff changeset
538 wrap = s->block_wrap[0];
252444e5259b optimization
michaelni
parents: 265
diff changeset
539 xy = s->block_index[block];
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
540
245
a023f78e0cc2 * simplified indexing
kabi
parents: 241
diff changeset
541 mot_val = s->motion_val[xy];
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
542
986e461dc072 Initial revision
glantau
parents:
diff changeset
543 /* special case for first line */
272
897dc7c6aa94 fixing 4MV
michaelni
parents: 266
diff changeset
544 if ((s->mb_y == 0 || s->first_slice_line || s->first_gob_line) && block<2) {
245
a023f78e0cc2 * simplified indexing
kabi
parents: 241
diff changeset
545 A = s->motion_val[xy - 1];
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
546 *px = A[0];
986e461dc072 Initial revision
glantau
parents:
diff changeset
547 *py = A[1];
986e461dc072 Initial revision
glantau
parents:
diff changeset
548 } else {
264
28c5c62b1c4c support decoding (with mplayer) of 3 .mp4 files from mphq
michaelni
parents: 263
diff changeset
549 A = s->motion_val[xy - 1];
28c5c62b1c4c support decoding (with mplayer) of 3 .mp4 files from mphq
michaelni
parents: 263
diff changeset
550 B = s->motion_val[xy - wrap];
28c5c62b1c4c support decoding (with mplayer) of 3 .mp4 files from mphq
michaelni
parents: 263
diff changeset
551 C = s->motion_val[xy + off[block] - wrap];
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
552 *px = mid_pred(A[0], B[0], C[0]);
986e461dc072 Initial revision
glantau
parents:
diff changeset
553 *py = mid_pred(A[1], B[1], C[1]);
986e461dc072 Initial revision
glantau
parents:
diff changeset
554 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
555 return mot_val;
986e461dc072 Initial revision
glantau
parents:
diff changeset
556 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
557
986e461dc072 Initial revision
glantau
parents:
diff changeset
558 static void h263_encode_motion(MpegEncContext * s, int val)
986e461dc072 Initial revision
glantau
parents:
diff changeset
559 {
986e461dc072 Initial revision
glantau
parents:
diff changeset
560 int range, l, m, bit_size, sign, code, bits;
986e461dc072 Initial revision
glantau
parents:
diff changeset
561
986e461dc072 Initial revision
glantau
parents:
diff changeset
562 if (val == 0) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
563 /* zero vector */
986e461dc072 Initial revision
glantau
parents:
diff changeset
564 code = 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
565 put_bits(&s->pb, mvtab[code][1], mvtab[code][0]);
986e461dc072 Initial revision
glantau
parents:
diff changeset
566 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
567 bit_size = s->f_code - 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
568 range = 1 << bit_size;
986e461dc072 Initial revision
glantau
parents:
diff changeset
569 /* modulo encoding */
986e461dc072 Initial revision
glantau
parents:
diff changeset
570 l = range * 32;
986e461dc072 Initial revision
glantau
parents:
diff changeset
571 m = 2 * l;
986e461dc072 Initial revision
glantau
parents:
diff changeset
572 if (val < -l) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
573 val += m;
986e461dc072 Initial revision
glantau
parents:
diff changeset
574 } else if (val >= l) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
575 val -= m;
986e461dc072 Initial revision
glantau
parents:
diff changeset
576 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
577
986e461dc072 Initial revision
glantau
parents:
diff changeset
578 if (val >= 0) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
579 val--;
986e461dc072 Initial revision
glantau
parents:
diff changeset
580 code = (val >> bit_size) + 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
581 bits = val & (range - 1);
986e461dc072 Initial revision
glantau
parents:
diff changeset
582 sign = 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
583 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
584 val = -val;
986e461dc072 Initial revision
glantau
parents:
diff changeset
585 val--;
986e461dc072 Initial revision
glantau
parents:
diff changeset
586 code = (val >> bit_size) + 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
587 bits = val & (range - 1);
986e461dc072 Initial revision
glantau
parents:
diff changeset
588 sign = 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
589 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
590
986e461dc072 Initial revision
glantau
parents:
diff changeset
591 put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign);
986e461dc072 Initial revision
glantau
parents:
diff changeset
592 if (bit_size > 0) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
593 put_bits(&s->pb, bit_size, bits);
986e461dc072 Initial revision
glantau
parents:
diff changeset
594 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
595 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
596 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
597
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
598 /* Encode MV differences on H.263+ with Unrestricted MV mode */
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
599 static void h263p_encode_umotion(MpegEncContext * s, int val)
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
600 {
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
601 short sval = 0;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
602 short i = 0;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
603 short n_bits = 0;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
604 short temp_val;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
605 int code = 0;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
606 int tcode;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
607
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
608 if ( val == 0)
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
609 put_bits(&s->pb, 1, 1);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
610 else if (val == 1)
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
611 put_bits(&s->pb, 3, 0);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
612 else if (val == -1)
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
613 put_bits(&s->pb, 3, 2);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
614 else {
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
615
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
616 sval = ((val < 0) ? (short)(-val):(short)val);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
617 temp_val = sval;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
618
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
619 while (temp_val != 0) {
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
620 temp_val = temp_val >> 1;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
621 n_bits++;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
622 }
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
623
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
624 i = n_bits - 1;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
625 while (i > 0) {
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
626 tcode = (sval & (1 << (i-1))) >> (i-1);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
627 tcode = (tcode << 1) | 1;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
628 code = (code << 2) | tcode;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
629 i--;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
630 }
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
631 code = ((code << 1) | (val < 0)) << 1;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
632 put_bits(&s->pb, (2*n_bits)+1, code);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
633 //printf("\nVal = %d\tCode = %d", sval, code);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
634 }
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
635 }
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
636
277
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
637 static void init_mv_penalty_and_fcode(MpegEncContext *s)
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
638 {
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
639 int f_code;
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
640 int mv;
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
641 for(f_code=1; f_code<=MAX_FCODE; f_code++){
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
642 for(mv=-MAX_MV; mv<=MAX_MV; mv++){
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
643 int len;
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
644
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
645 if(mv==0) len= mvtab[0][1];
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
646 else{
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
647 int val, bit_size, range, code;
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
648
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
649 bit_size = s->f_code - 1;
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
650 range = 1 << bit_size;
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
651
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
652 val=mv;
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
653 if (val < 0)
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
654 val = -val;
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
655 val--;
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
656 code = (val >> bit_size) + 1;
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
657 if(code<33){
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
658 len= mvtab[code][1] + 1 + bit_size;
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
659 }else{
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
660 len= mvtab[32][1] + 2 + bit_size;
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
661 }
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
662 }
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
663
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
664 mv_penalty[f_code][mv+MAX_MV]= len;
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
665 }
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
666 }
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
667
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
668
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
669 for(f_code=MAX_FCODE; f_code>0; f_code--){
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
670 for(mv=-(16<<f_code); mv<(16<<f_code); mv++){
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
671 fcode_tab[mv+MAX_MV]= f_code;
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
672 }
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
673 }
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
674 }
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
675
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
676 void h263_encode_init(MpegEncContext *s)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
677 {
986e461dc072 Initial revision
glantau
parents:
diff changeset
678 static int done = 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
679
986e461dc072 Initial revision
glantau
parents:
diff changeset
680 if (!done) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
681 done = 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
682 init_rl(&rl_inter);
986e461dc072 Initial revision
glantau
parents:
diff changeset
683 init_rl(&rl_intra);
277
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
684
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
685 init_mv_penalty_and_fcode(s);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
686 }
277
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
687 s->mv_penalty= mv_penalty;
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
688
283
d94f9f58a2c5 fixing MV range in h263
michaelni
parents: 281
diff changeset
689 // use fcodes >1 only for mpeg4&h263 FIXME
d94f9f58a2c5 fixing MV range in h263
michaelni
parents: 281
diff changeset
690 if(!s->h263_msmpeg4) s->fcode_tab= fcode_tab;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
691 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
692
986e461dc072 Initial revision
glantau
parents:
diff changeset
693 static void h263_encode_block(MpegEncContext * s, DCTELEM * block, int n)
986e461dc072 Initial revision
glantau
parents:
diff changeset
694 {
986e461dc072 Initial revision
glantau
parents:
diff changeset
695 int level, run, last, i, j, last_index, last_non_zero, sign, slevel;
986e461dc072 Initial revision
glantau
parents:
diff changeset
696 int code;
986e461dc072 Initial revision
glantau
parents:
diff changeset
697 RLTable *rl = &rl_inter;
986e461dc072 Initial revision
glantau
parents:
diff changeset
698
986e461dc072 Initial revision
glantau
parents:
diff changeset
699 if (s->mb_intra) {
231
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
700 /* DC coef */
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
701 level = block[0];
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
702 /* 255 cannot be represented, so we clamp */
986e461dc072 Initial revision
glantau
parents:
diff changeset
703 if (level > 254) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
704 level = 254;
986e461dc072 Initial revision
glantau
parents:
diff changeset
705 block[0] = 254;
986e461dc072 Initial revision
glantau
parents:
diff changeset
706 }
231
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
707 /* 0 cannot be represented also */
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
708 else if (!level) {
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
709 level = 1;
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
710 block[0] = 1;
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
711 }
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
712 if (level == 128)
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
713 put_bits(&s->pb, 8, 0xff);
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
714 else
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
715 put_bits(&s->pb, 8, level & 0xff);
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
716 i = 1;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
717 } else {
231
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
718 i = 0;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
719 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
720
986e461dc072 Initial revision
glantau
parents:
diff changeset
721 /* AC coefs */
986e461dc072 Initial revision
glantau
parents:
diff changeset
722 last_index = s->block_last_index[n];
986e461dc072 Initial revision
glantau
parents:
diff changeset
723 last_non_zero = i - 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
724 for (; i <= last_index; i++) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
725 j = zigzag_direct[i];
986e461dc072 Initial revision
glantau
parents:
diff changeset
726 level = block[j];
986e461dc072 Initial revision
glantau
parents:
diff changeset
727 if (level) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
728 run = i - last_non_zero - 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
729 last = (i == last_index);
986e461dc072 Initial revision
glantau
parents:
diff changeset
730 sign = 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
731 slevel = level;
986e461dc072 Initial revision
glantau
parents:
diff changeset
732 if (level < 0) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
733 sign = 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
734 level = -level;
986e461dc072 Initial revision
glantau
parents:
diff changeset
735 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
736 code = get_rl_index(rl, last, run, level);
986e461dc072 Initial revision
glantau
parents:
diff changeset
737 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
986e461dc072 Initial revision
glantau
parents:
diff changeset
738 if (code == rl->n) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
739 put_bits(&s->pb, 1, last);
986e461dc072 Initial revision
glantau
parents:
diff changeset
740 put_bits(&s->pb, 6, run);
986e461dc072 Initial revision
glantau
parents:
diff changeset
741 put_bits(&s->pb, 8, slevel & 0xff);
986e461dc072 Initial revision
glantau
parents:
diff changeset
742 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
743 put_bits(&s->pb, 1, sign);
986e461dc072 Initial revision
glantau
parents:
diff changeset
744 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
745 last_non_zero = i;
986e461dc072 Initial revision
glantau
parents:
diff changeset
746 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
747 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
748 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
749
986e461dc072 Initial revision
glantau
parents:
diff changeset
750 /***************************************************/
986e461dc072 Initial revision
glantau
parents:
diff changeset
751
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
752 static void mpeg4_stuffing(PutBitContext * pbc)
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
753 {
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
754 int length;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
755 put_bits(pbc, 1, 0);
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
756 length= (-get_bit_count(pbc))&7;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
757 put_bits(pbc, length, (1<<length)-1);
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
758 }
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
759
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
760 static void put_string(PutBitContext * pbc, char *s)
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
761 {
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
762 while(*s){
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
763 put_bits(pbc, 8, *s);
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
764 s++;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
765 }
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
766 put_bits(pbc, 8, 0);
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
767 }
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
768
263
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
769 static void mpeg4_encode_vol_header(MpegEncContext * s)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
770 {
263
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
771 int vo_ver_id=1; //must be 2 if we want GMC or q-pel
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
772
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
773 if(get_bit_count(&s->pb)!=0) mpeg4_stuffing(&s->pb);
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
774 put_bits(&s->pb, 16, 0);
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
775 put_bits(&s->pb, 16, 0x100); /* video obj */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
776 put_bits(&s->pb, 16, 0);
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
777 put_bits(&s->pb, 16, 0x120); /* video obj layer */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
778
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
779 put_bits(&s->pb, 1, 0); /* random access vol */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
780 put_bits(&s->pb, 8, 1); /* video obj type indication= simple obj */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
781 put_bits(&s->pb, 1, 1); /* is obj layer id= yes */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
782 put_bits(&s->pb, 4, vo_ver_id); /* is obj layer ver id */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
783 put_bits(&s->pb, 3, 1); /* is obj layer priority */
281
1fc96b02142e mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents: 278
diff changeset
784 if(s->aspect_ratio_info)
1fc96b02142e mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents: 278
diff changeset
785 put_bits(&s->pb, 4, s->aspect_ratio_info);/* aspect ratio info */
1fc96b02142e mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents: 278
diff changeset
786 else
1fc96b02142e mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents: 278
diff changeset
787 put_bits(&s->pb, 4, 1); /* aspect ratio info= sqare pixel */
263
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
788 put_bits(&s->pb, 1, 0); /* vol control parameters= no */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
789 put_bits(&s->pb, 2, RECT_SHAPE); /* vol shape= rectangle */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
790 put_bits(&s->pb, 1, 1); /* marker bit */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
791 put_bits(&s->pb, 16, s->time_increment_resolution=30000);
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
792 s->time_increment_bits = av_log2(s->time_increment_resolution - 1) + 1;
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
793 if (s->time_increment_bits < 1)
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
794 s->time_increment_bits = 1;
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
795 put_bits(&s->pb, 1, 1); /* marker bit */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
796 put_bits(&s->pb, 1, 0); /* fixed vop rate=no */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
797 put_bits(&s->pb, 1, 1); /* marker bit */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
798 put_bits(&s->pb, 13, s->width); /* vol width */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
799 put_bits(&s->pb, 1, 1); /* marker bit */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
800 put_bits(&s->pb, 13, s->height); /* vol height */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
801 put_bits(&s->pb, 1, 1); /* marker bit */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
802 put_bits(&s->pb, 1, 0); /* interlace */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
803 put_bits(&s->pb, 1, 1); /* obmc disable */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
804 if (vo_ver_id == 1) {
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
805 put_bits(&s->pb, 1, s->vol_sprite_usage=0); /* sprite enable */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
806 }else{ /* vo_ver_id == 2 */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
807 put_bits(&s->pb, 2, s->vol_sprite_usage=0); /* sprite enable */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
808 }
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
809 put_bits(&s->pb, 1, 0); /* not 8 bit */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
810 put_bits(&s->pb, 1, 0); /* quant type= h263 style*/
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
811 if (vo_ver_id != 1)
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
812 put_bits(&s->pb, 1, s->quarter_sample=0);
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
813 put_bits(&s->pb, 1, 1); /* complexity estimation disable */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
814 put_bits(&s->pb, 1, 1); /* resync marker disable */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
815 put_bits(&s->pb, 1, 0); /* data partitioned */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
816 if (vo_ver_id != 1){
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
817 put_bits(&s->pb, 1, 0); /* newpred */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
818 put_bits(&s->pb, 1, 0); /* reduced res vop */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
819 }
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
820 put_bits(&s->pb, 1, 0); /* scalability */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
821
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
822 mpeg4_stuffing(&s->pb);
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
823 put_bits(&s->pb, 16, 0);
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
824 put_bits(&s->pb, 16, 0x1B2); /* user_data */
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
825 put_string(&s->pb, "ffmpeg"); //FIXME append some version ...
264
28c5c62b1c4c support decoding (with mplayer) of 3 .mp4 files from mphq
michaelni
parents: 263
diff changeset
826
28c5c62b1c4c support decoding (with mplayer) of 3 .mp4 files from mphq
michaelni
parents: 263
diff changeset
827 s->no_rounding = 0;
263
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
828 }
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
829
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
830 /* write mpeg4 VOP header */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
831 void mpeg4_encode_picture_header(MpegEncContext * s, int picture_number)
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
832 {
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
833 if(s->pict_type==I_TYPE) mpeg4_encode_vol_header(s);
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
834
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
835 if(get_bit_count(&s->pb)!=0) mpeg4_stuffing(&s->pb);
234
5fc0c3af3fe4 alternative bitstream writer (disabled by default, uncomment #define ALT_BISTREAM_WRITER in common.h if u want to try it)
michaelni
parents: 231
diff changeset
836 put_bits(&s->pb, 16, 0); /* vop header */
5fc0c3af3fe4 alternative bitstream writer (disabled by default, uncomment #define ALT_BISTREAM_WRITER in common.h if u want to try it)
michaelni
parents: 231
diff changeset
837 put_bits(&s->pb, 16, 0x1B6); /* vop header */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
838 put_bits(&s->pb, 2, s->pict_type - 1); /* pict type: I = 0 , P = 1 */
986e461dc072 Initial revision
glantau
parents:
diff changeset
839 /* XXX: time base + 1 not always correct */
986e461dc072 Initial revision
glantau
parents:
diff changeset
840 put_bits(&s->pb, 1, 1);
986e461dc072 Initial revision
glantau
parents:
diff changeset
841 put_bits(&s->pb, 1, 0);
986e461dc072 Initial revision
glantau
parents:
diff changeset
842
986e461dc072 Initial revision
glantau
parents:
diff changeset
843 put_bits(&s->pb, 1, 1); /* marker */
263
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
844 put_bits(&s->pb, s->time_increment_bits, 1); /* XXX: correct time increment */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
845 put_bits(&s->pb, 1, 1); /* marker */
986e461dc072 Initial revision
glantau
parents:
diff changeset
846 put_bits(&s->pb, 1, 1); /* vop coded */
263
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
847 if ( s->pict_type == P_TYPE
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
848 || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE)) {
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
849 s->no_rounding ^= 1;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
850 put_bits(&s->pb, 1, s->no_rounding); /* rounding type */
986e461dc072 Initial revision
glantau
parents:
diff changeset
851 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
852 put_bits(&s->pb, 3, 0); /* intra dc VLC threshold */
263
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
853 //FIXME sprite stuff
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
854
986e461dc072 Initial revision
glantau
parents:
diff changeset
855 put_bits(&s->pb, 5, s->qscale);
986e461dc072 Initial revision
glantau
parents:
diff changeset
856
986e461dc072 Initial revision
glantau
parents:
diff changeset
857 if (s->pict_type != I_TYPE)
986e461dc072 Initial revision
glantau
parents:
diff changeset
858 put_bits(&s->pb, 3, s->f_code); /* fcode_for */
263
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
859 if (s->pict_type == B_TYPE)
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
860 put_bits(&s->pb, 3, s->b_code); /* fcode_back */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
861 // printf("****frame %d\n", picture_number);
986e461dc072 Initial revision
glantau
parents:
diff changeset
862 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
863
986e461dc072 Initial revision
glantau
parents:
diff changeset
864 void h263_dc_scale(MpegEncContext * s)
986e461dc072 Initial revision
glantau
parents:
diff changeset
865 {
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
866 #if 1
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
867 const static UINT8 y_tab[32]={
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
868 // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
869 0, 8, 8, 8, 8,10,12,14,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,34,36,38,40,42,44,46
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
870 };
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
871 const static UINT8 c_tab[32]={
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
872 // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
873 0, 8, 8, 8, 8, 9, 9,10,10,11,11,12,12,13,13,14,14,15,15,16,16,17,17,18,18,19,20,21,22,23,24,25
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
874 };
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
875 s->y_dc_scale = y_tab[s->qscale];
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
876 s->c_dc_scale = c_tab[s->qscale];
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
877 #else
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
878 int quant;
986e461dc072 Initial revision
glantau
parents:
diff changeset
879 quant = s->qscale;
986e461dc072 Initial revision
glantau
parents:
diff changeset
880 /* luminance */
986e461dc072 Initial revision
glantau
parents:
diff changeset
881 if (quant < 5)
986e461dc072 Initial revision
glantau
parents:
diff changeset
882 s->y_dc_scale = 8;
986e461dc072 Initial revision
glantau
parents:
diff changeset
883 else if (quant > 4 && quant < 9)
986e461dc072 Initial revision
glantau
parents:
diff changeset
884 s->y_dc_scale = (2 * quant);
986e461dc072 Initial revision
glantau
parents:
diff changeset
885 else if (quant > 8 && quant < 25)
986e461dc072 Initial revision
glantau
parents:
diff changeset
886 s->y_dc_scale = (quant + 8);
986e461dc072 Initial revision
glantau
parents:
diff changeset
887 else
986e461dc072 Initial revision
glantau
parents:
diff changeset
888 s->y_dc_scale = (2 * quant - 16);
986e461dc072 Initial revision
glantau
parents:
diff changeset
889 /* chrominance */
986e461dc072 Initial revision
glantau
parents:
diff changeset
890 if (quant < 5)
986e461dc072 Initial revision
glantau
parents:
diff changeset
891 s->c_dc_scale = 8;
986e461dc072 Initial revision
glantau
parents:
diff changeset
892 else if (quant > 4 && quant < 25)
986e461dc072 Initial revision
glantau
parents:
diff changeset
893 s->c_dc_scale = ((quant + 13) / 2);
986e461dc072 Initial revision
glantau
parents:
diff changeset
894 else
986e461dc072 Initial revision
glantau
parents:
diff changeset
895 s->c_dc_scale = (quant - 6);
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
896 #endif
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
897 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
898
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
899 static inline int mpeg4_pred_dc(MpegEncContext * s, int n, UINT16 **dc_val_ptr, int *dir_ptr)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
900 {
266
252444e5259b optimization
michaelni
parents: 265
diff changeset
901 int a, b, c, wrap, pred, scale;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
902 UINT16 *dc_val;
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
903 int dummy;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
904
986e461dc072 Initial revision
glantau
parents:
diff changeset
905 /* find prediction */
986e461dc072 Initial revision
glantau
parents:
diff changeset
906 if (n < 4) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
907 scale = s->y_dc_scale;
986e461dc072 Initial revision
glantau
parents:
diff changeset
908 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
909 scale = s->c_dc_scale;
986e461dc072 Initial revision
glantau
parents:
diff changeset
910 }
266
252444e5259b optimization
michaelni
parents: 265
diff changeset
911 wrap= s->block_wrap[n];
252444e5259b optimization
michaelni
parents: 265
diff changeset
912 dc_val = s->dc_val[0] + s->block_index[n];
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
913
986e461dc072 Initial revision
glantau
parents:
diff changeset
914 /* B C
986e461dc072 Initial revision
glantau
parents:
diff changeset
915 * A X
986e461dc072 Initial revision
glantau
parents:
diff changeset
916 */
266
252444e5259b optimization
michaelni
parents: 265
diff changeset
917 a = dc_val[ - 1];
252444e5259b optimization
michaelni
parents: 265
diff changeset
918 b = dc_val[ - 1 - wrap];
252444e5259b optimization
michaelni
parents: 265
diff changeset
919 c = dc_val[ - wrap];
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
920
986e461dc072 Initial revision
glantau
parents:
diff changeset
921 if (abs(a - b) < abs(b - c)) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
922 pred = c;
986e461dc072 Initial revision
glantau
parents:
diff changeset
923 *dir_ptr = 1; /* top */
986e461dc072 Initial revision
glantau
parents:
diff changeset
924 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
925 pred = a;
986e461dc072 Initial revision
glantau
parents:
diff changeset
926 *dir_ptr = 0; /* left */
986e461dc072 Initial revision
glantau
parents:
diff changeset
927 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
928 /* we assume pred is positive */
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
929 #ifdef ARCH_X86
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
930 asm volatile (
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
931 "xorl %%edx, %%edx \n\t"
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
932 "mul %%ecx \n\t"
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
933 : "=d" (pred), "=a"(dummy)
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
934 : "a" (pred + (scale >> 1)), "c" (inverse[scale])
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
935 );
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
936 #else
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
937 pred = (pred + (scale >> 1)) / scale;
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
938 #endif
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
939
986e461dc072 Initial revision
glantau
parents:
diff changeset
940 /* prepare address for prediction update */
266
252444e5259b optimization
michaelni
parents: 265
diff changeset
941 *dc_val_ptr = &dc_val[0];
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
942
986e461dc072 Initial revision
glantau
parents:
diff changeset
943 return pred;
986e461dc072 Initial revision
glantau
parents:
diff changeset
944 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
945
174
ac5075a55488 new IDCT code by Michael Niedermayer (michaelni@gmx.at) - #define SIMPLE_IDCT to enable
arpi_esp
parents: 162
diff changeset
946 void mpeg4_pred_ac(MpegEncContext * s, INT16 *block, int n,
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
947 int dir)
986e461dc072 Initial revision
glantau
parents:
diff changeset
948 {
266
252444e5259b optimization
michaelni
parents: 265
diff changeset
949 int i;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
950 INT16 *ac_val, *ac_val1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
951
986e461dc072 Initial revision
glantau
parents:
diff changeset
952 /* find prediction */
266
252444e5259b optimization
michaelni
parents: 265
diff changeset
953 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
954 ac_val1 = ac_val;
986e461dc072 Initial revision
glantau
parents:
diff changeset
955 if (s->ac_pred) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
956 if (dir == 0) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
957 /* left prediction */
986e461dc072 Initial revision
glantau
parents:
diff changeset
958 ac_val -= 16;
986e461dc072 Initial revision
glantau
parents:
diff changeset
959 for(i=1;i<8;i++) {
174
ac5075a55488 new IDCT code by Michael Niedermayer (michaelni@gmx.at) - #define SIMPLE_IDCT to enable
arpi_esp
parents: 162
diff changeset
960 block[block_permute_op(i*8)] += ac_val[i];
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
961 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
962 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
963 /* top prediction */
266
252444e5259b optimization
michaelni
parents: 265
diff changeset
964 ac_val -= 16 * s->block_wrap[n];
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
965 for(i=1;i<8;i++) {
174
ac5075a55488 new IDCT code by Michael Niedermayer (michaelni@gmx.at) - #define SIMPLE_IDCT to enable
arpi_esp
parents: 162
diff changeset
966 block[block_permute_op(i)] += ac_val[i + 8];
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
967 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
968 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
969 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
970 /* left copy */
986e461dc072 Initial revision
glantau
parents:
diff changeset
971 for(i=1;i<8;i++)
174
ac5075a55488 new IDCT code by Michael Niedermayer (michaelni@gmx.at) - #define SIMPLE_IDCT to enable
arpi_esp
parents: 162
diff changeset
972 ac_val1[i] = block[block_permute_op(i * 8)];
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
973 /* top copy */
986e461dc072 Initial revision
glantau
parents:
diff changeset
974 for(i=1;i<8;i++)
174
ac5075a55488 new IDCT code by Michael Niedermayer (michaelni@gmx.at) - #define SIMPLE_IDCT to enable
arpi_esp
parents: 162
diff changeset
975 ac_val1[8 + i] = block[block_permute_op(i)];
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
976 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
977
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
978 static void mpeg4_inv_pred_ac(MpegEncContext * s, INT16 *block, int n,
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
979 int dir)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
980 {
266
252444e5259b optimization
michaelni
parents: 265
diff changeset
981 int i;
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
982 INT16 *ac_val;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
983
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
984 /* find prediction */
266
252444e5259b optimization
michaelni
parents: 265
diff changeset
985 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
986
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
987 if (dir == 0) {
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
988 /* left prediction */
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
989 ac_val -= 16;
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
990 for(i=1;i<8;i++) {
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
991 block[block_permute_op(i*8)] -= ac_val[i];
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
992 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
993 } else {
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
994 /* top prediction */
266
252444e5259b optimization
michaelni
parents: 265
diff changeset
995 ac_val -= 16 * s->block_wrap[n];
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
996 for(i=1;i<8;i++) {
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
997 block[block_permute_op(i)] -= ac_val[i + 8];
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
998 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
999 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1000 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1001
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1002
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1003 static inline void mpeg4_encode_dc(MpegEncContext * s, int level, int n)
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1004 {
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1005 int size, v;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1006 /* find number of bits */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1007 size = 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1008 v = abs(level);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1009 while (v) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1010 v >>= 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1011 size++;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1012 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1013
986e461dc072 Initial revision
glantau
parents:
diff changeset
1014 if (n < 4) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1015 /* luminance */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1016 put_bits(&s->pb, DCtab_lum[size][1], DCtab_lum[size][0]);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1017 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1018 /* chrominance */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1019 put_bits(&s->pb, DCtab_chrom[size][1], DCtab_chrom[size][0]);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1020 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1021
986e461dc072 Initial revision
glantau
parents:
diff changeset
1022 /* encode remaining bits */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1023 if (size > 0) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1024 if (level < 0)
986e461dc072 Initial revision
glantau
parents:
diff changeset
1025 level = (-level) ^ ((1 << size) - 1);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1026 put_bits(&s->pb, size, level);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1027 if (size > 8)
986e461dc072 Initial revision
glantau
parents:
diff changeset
1028 put_bits(&s->pb, 1, 1);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1029 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1030 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1031
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1032 static void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n, int intra_dc, UINT8 *scan_table)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1033 {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1034 int level, run, last, i, j, last_index, last_non_zero, sign, slevel;
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1035 int code;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1036 const RLTable *rl;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1037
986e461dc072 Initial revision
glantau
parents:
diff changeset
1038 if (s->mb_intra) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1039 /* mpeg4 based DC predictor */
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1040 mpeg4_encode_dc(s, intra_dc, n);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1041 i = 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1042 rl = &rl_intra;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1043 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1044 i = 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1045 rl = &rl_inter;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1046 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1047
986e461dc072 Initial revision
glantau
parents:
diff changeset
1048 /* AC coefs */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1049 last_index = s->block_last_index[n];
986e461dc072 Initial revision
glantau
parents:
diff changeset
1050 last_non_zero = i - 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1051 for (; i <= last_index; i++) {
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1052 j = scan_table[i];
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1053 level = block[j];
986e461dc072 Initial revision
glantau
parents:
diff changeset
1054 if (level) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1055 run = i - last_non_zero - 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1056 last = (i == last_index);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1057 sign = 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1058 slevel = level;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1059 if (level < 0) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1060 sign = 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1061 level = -level;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1062 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1063 code = get_rl_index(rl, last, run, level);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1064 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1065 if (code == rl->n) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1066 int level1, run1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1067 level1 = level - rl->max_level[last][run];
986e461dc072 Initial revision
glantau
parents:
diff changeset
1068 if (level1 < 1)
986e461dc072 Initial revision
glantau
parents:
diff changeset
1069 goto esc2;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1070 code = get_rl_index(rl, last, run, level1);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1071 if (code == rl->n) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1072 esc2:
986e461dc072 Initial revision
glantau
parents:
diff changeset
1073 put_bits(&s->pb, 1, 1);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1074 if (level > MAX_LEVEL)
986e461dc072 Initial revision
glantau
parents:
diff changeset
1075 goto esc3;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1076 run1 = run - rl->max_run[last][level] - 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1077 if (run1 < 0)
986e461dc072 Initial revision
glantau
parents:
diff changeset
1078 goto esc3;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1079 code = get_rl_index(rl, last, run1, level);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1080 if (code == rl->n) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1081 esc3:
986e461dc072 Initial revision
glantau
parents:
diff changeset
1082 /* third escape */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1083 put_bits(&s->pb, 1, 1);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1084 put_bits(&s->pb, 1, last);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1085 put_bits(&s->pb, 6, run);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1086 put_bits(&s->pb, 1, 1);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1087 put_bits(&s->pb, 12, slevel & 0xfff);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1088 put_bits(&s->pb, 1, 1);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1089 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1090 /* second escape */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1091 put_bits(&s->pb, 1, 0);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1092 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1093 put_bits(&s->pb, 1, sign);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1094 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1095 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1096 /* first escape */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1097 put_bits(&s->pb, 1, 0);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1098 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1099 put_bits(&s->pb, 1, sign);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1100 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1101 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1102 put_bits(&s->pb, 1, sign);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1103 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1104 last_non_zero = i;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1105 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1106 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1107 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1108
986e461dc072 Initial revision
glantau
parents:
diff changeset
1109
986e461dc072 Initial revision
glantau
parents:
diff changeset
1110
986e461dc072 Initial revision
glantau
parents:
diff changeset
1111 /***********************************************/
986e461dc072 Initial revision
glantau
parents:
diff changeset
1112 /* decoding */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1113
986e461dc072 Initial revision
glantau
parents:
diff changeset
1114 static VLC intra_MCBPC_vlc;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1115 static VLC inter_MCBPC_vlc;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1116 static VLC cbpy_vlc;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1117 static VLC mv_vlc;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1118 static VLC dc_lum, dc_chrom;
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
1119 static VLC sprite_trajectory;
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1120 static VLC mb_type_b_vlc;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1121
986e461dc072 Initial revision
glantau
parents:
diff changeset
1122 void init_rl(RLTable *rl)
986e461dc072 Initial revision
glantau
parents:
diff changeset
1123 {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1124 INT8 max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
986e461dc072 Initial revision
glantau
parents:
diff changeset
1125 UINT8 index_run[MAX_RUN+1];
986e461dc072 Initial revision
glantau
parents:
diff changeset
1126 int last, run, level, start, end, i;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1127
986e461dc072 Initial revision
glantau
parents:
diff changeset
1128 /* compute max_level[], max_run[] and index_run[] */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1129 for(last=0;last<2;last++) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1130 if (last == 0) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1131 start = 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1132 end = rl->last;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1133 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1134 start = rl->last;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1135 end = rl->n;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1136 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1137
986e461dc072 Initial revision
glantau
parents:
diff changeset
1138 memset(max_level, 0, MAX_RUN + 1);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1139 memset(max_run, 0, MAX_LEVEL + 1);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1140 memset(index_run, rl->n, MAX_RUN + 1);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1141 for(i=start;i<end;i++) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1142 run = rl->table_run[i];
986e461dc072 Initial revision
glantau
parents:
diff changeset
1143 level = rl->table_level[i];
986e461dc072 Initial revision
glantau
parents:
diff changeset
1144 if (index_run[run] == rl->n)
986e461dc072 Initial revision
glantau
parents:
diff changeset
1145 index_run[run] = i;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1146 if (level > max_level[run])
986e461dc072 Initial revision
glantau
parents:
diff changeset
1147 max_level[run] = level;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1148 if (run > max_run[level])
986e461dc072 Initial revision
glantau
parents:
diff changeset
1149 max_run[level] = run;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1150 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1151 rl->max_level[last] = malloc(MAX_RUN + 1);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1152 memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1153 rl->max_run[last] = malloc(MAX_LEVEL + 1);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1154 memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1155 rl->index_run[last] = malloc(MAX_RUN + 1);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1156 memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1157 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1158 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1159
986e461dc072 Initial revision
glantau
parents:
diff changeset
1160 void init_vlc_rl(RLTable *rl)
986e461dc072 Initial revision
glantau
parents:
diff changeset
1161 {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1162 init_vlc(&rl->vlc, 9, rl->n + 1,
986e461dc072 Initial revision
glantau
parents:
diff changeset
1163 &rl->table_vlc[0][1], 4, 2,
986e461dc072 Initial revision
glantau
parents:
diff changeset
1164 &rl->table_vlc[0][0], 4, 2);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1165 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1166
986e461dc072 Initial revision
glantau
parents:
diff changeset
1167 /* init vlcs */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1168
986e461dc072 Initial revision
glantau
parents:
diff changeset
1169 /* XXX: find a better solution to handle static init */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1170 void h263_decode_init_vlc(MpegEncContext *s)
986e461dc072 Initial revision
glantau
parents:
diff changeset
1171 {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1172 static int done = 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1173
986e461dc072 Initial revision
glantau
parents:
diff changeset
1174 if (!done) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1175 done = 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1176
986e461dc072 Initial revision
glantau
parents:
diff changeset
1177 init_vlc(&intra_MCBPC_vlc, 6, 8,
986e461dc072 Initial revision
glantau
parents:
diff changeset
1178 intra_MCBPC_bits, 1, 1,
986e461dc072 Initial revision
glantau
parents:
diff changeset
1179 intra_MCBPC_code, 1, 1);
161
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
1180 init_vlc(&inter_MCBPC_vlc, 9, 25,
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1181 inter_MCBPC_bits, 1, 1,
986e461dc072 Initial revision
glantau
parents:
diff changeset
1182 inter_MCBPC_code, 1, 1);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1183 init_vlc(&cbpy_vlc, 6, 16,
986e461dc072 Initial revision
glantau
parents:
diff changeset
1184 &cbpy_tab[0][1], 2, 1,
986e461dc072 Initial revision
glantau
parents:
diff changeset
1185 &cbpy_tab[0][0], 2, 1);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1186 init_vlc(&mv_vlc, 9, 33,
986e461dc072 Initial revision
glantau
parents:
diff changeset
1187 &mvtab[0][1], 2, 1,
986e461dc072 Initial revision
glantau
parents:
diff changeset
1188 &mvtab[0][0], 2, 1);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1189 init_rl(&rl_inter);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1190 init_rl(&rl_intra);
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1191 init_rl(&rl_intra_aic);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1192 init_vlc_rl(&rl_inter);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1193 init_vlc_rl(&rl_intra);
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1194 init_vlc_rl(&rl_intra_aic);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1195 init_vlc(&dc_lum, 9, 13,
986e461dc072 Initial revision
glantau
parents:
diff changeset
1196 &DCtab_lum[0][1], 2, 1,
986e461dc072 Initial revision
glantau
parents:
diff changeset
1197 &DCtab_lum[0][0], 2, 1);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1198 init_vlc(&dc_chrom, 9, 13,
986e461dc072 Initial revision
glantau
parents:
diff changeset
1199 &DCtab_chrom[0][1], 2, 1,
986e461dc072 Initial revision
glantau
parents:
diff changeset
1200 &DCtab_chrom[0][0], 2, 1);
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
1201 init_vlc(&sprite_trajectory, 9, 15,
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
1202 &sprite_trajectory_tab[0][1], 4, 2,
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
1203 &sprite_trajectory_tab[0][0], 4, 2);
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1204 init_vlc(&mb_type_b_vlc, 4, 4,
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1205 &mb_type_b_tab[0][1], 2, 1,
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1206 &mb_type_b_tab[0][0], 2, 1);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1207 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1208 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1209
162
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
1210 int h263_decode_gob_header(MpegEncContext *s)
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
1211 {
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
1212 unsigned int val, gfid;
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
1213
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
1214 /* Check for GOB Start Code */
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
1215 val = show_bits(&s->gb, 16);
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
1216 if (val == 0) {
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
1217 /* We have a GBSC probably with GSTUFF */
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
1218 skip_bits(&s->gb, 16); /* Drop the zeros */
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
1219 while (get_bits1(&s->gb) == 0); /* Seek the '1' bit */
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
1220 #ifdef DEBUG
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
1221 fprintf(stderr,"\nGOB Start Code at MB %d\n", (s->mb_y * s->mb_width) + s->mb_x);
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
1222 #endif
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
1223 s->gob_number = get_bits(&s->gb, 5); /* GN */
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
1224 gfid = get_bits(&s->gb, 2); /* GFID */
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
1225 s->qscale = get_bits(&s->gb, 5); /* GQUANT */
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
1226 #ifdef DEBUG
234
5fc0c3af3fe4 alternative bitstream writer (disabled by default, uncomment #define ALT_BISTREAM_WRITER in common.h if u want to try it)
michaelni
parents: 231
diff changeset
1227 fprintf(stderr, "\nGN: %u GFID: %u Quant: %u\n", s->gob_number, gfid, s->qscale);
162
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
1228 #endif
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
1229 return 1;
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
1230 }
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
1231 return 0;
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
1232
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
1233 }
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
1234
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1235 int h263_decode_mb(MpegEncContext *s,
986e461dc072 Initial revision
glantau
parents:
diff changeset
1236 DCTELEM block[6][64])
986e461dc072 Initial revision
glantau
parents:
diff changeset
1237 {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1238 int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1239 INT16 *mot_val;
110
e00e5d93457c Added Juergen Keil fix on quant_tab[4] type.
pulento
parents: 79
diff changeset
1240 static INT8 quant_tab[4] = { -1, -2, 1, 2 };
264
28c5c62b1c4c support decoding (with mplayer) of 3 .mp4 files from mphq
michaelni
parents: 263
diff changeset
1241
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
1242 if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
1243 if (get_bits1(&s->gb)) {
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1244 /* skip mb */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1245 s->mb_intra = 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1246 for(i=0;i<6;i++)
986e461dc072 Initial revision
glantau
parents:
diff changeset
1247 s->block_last_index[i] = -1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1248 s->mv_dir = MV_DIR_FORWARD;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1249 s->mv_type = MV_TYPE_16X16;
255
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
1250 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
1251 const int a= s->sprite_warping_accuracy;
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
1252 // int l = (1 << (s->f_code - 1)) * 32;
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
1253
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
1254 s->mcsel=1;
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
1255 s->mv[0][0][0] = RSHIFT(s->sprite_offset[0][0], a-s->quarter_sample);
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
1256 s->mv[0][0][1] = RSHIFT(s->sprite_offset[0][1], a-s->quarter_sample);
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
1257 /* if (s->mv[0][0][0] < -l) s->mv[0][0][0]= -l;
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
1258 else if (s->mv[0][0][0] >= l) s->mv[0][0][0]= l-1;
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
1259 if (s->mv[0][0][1] < -l) s->mv[0][0][1]= -l;
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
1260 else if (s->mv[0][0][1] >= l) s->mv[0][0][1]= l-1;*/
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
1261
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
1262 s->mb_skiped = 0;
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
1263 }else{
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
1264 s->mcsel=0;
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
1265 s->mv[0][0][0] = 0;
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
1266 s->mv[0][0][1] = 0;
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
1267 s->mb_skiped = 1;
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
1268 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1269 return 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1270 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1271 cbpc = get_vlc(&s->gb, &inter_MCBPC_vlc);
144
cb5dabd00ba2 - Bug fix on inter MCBPC table for inter+q.
pulento
parents: 110
diff changeset
1272 //fprintf(stderr, "\tCBPC: %d", cbpc);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1273 if (cbpc < 0)
986e461dc072 Initial revision
glantau
parents:
diff changeset
1274 return -1;
161
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
1275 if (cbpc > 20)
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
1276 cbpc+=3;
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
1277 else if (cbpc == 20)
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
1278 fprintf(stderr, "Stuffing !");
144
cb5dabd00ba2 - Bug fix on inter MCBPC table for inter+q.
pulento
parents: 110
diff changeset
1279
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1280 dquant = cbpc & 8;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1281 s->mb_intra = ((cbpc & 4) != 0);
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1282 if (s->mb_intra) goto intra;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1283
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
1284 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
1285 s->mcsel= get_bits1(&s->gb);
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
1286 else s->mcsel= 0;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1287 cbpy = get_vlc(&s->gb, &cbpy_vlc);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1288 cbp = (cbpc & 3) | ((cbpy ^ 0xf) << 2);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1289 if (dquant) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1290 s->qscale += quant_tab[get_bits(&s->gb, 2)];
986e461dc072 Initial revision
glantau
parents:
diff changeset
1291 if (s->qscale < 1)
986e461dc072 Initial revision
glantau
parents:
diff changeset
1292 s->qscale = 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1293 else if (s->qscale > 31)
986e461dc072 Initial revision
glantau
parents:
diff changeset
1294 s->qscale = 31;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1295 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1296 s->mv_dir = MV_DIR_FORWARD;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1297 if ((cbpc & 16) == 0) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1298 /* 16x16 motion prediction */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1299 s->mv_type = MV_TYPE_16X16;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1300 h263_pred_motion(s, 0, &pred_x, &pred_y);
79
82e579c37bc3 Moved some H.263+ variables to MpegEncContext to be thread-safe.
pulento
parents: 78
diff changeset
1301 if (s->umvplus_dec)
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1302 mx = h263p_decode_umotion(s, pred_x);
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
1303 else if(!s->mcsel)
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1304 mx = h263_decode_motion(s, pred_x, s->f_code);
255
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
1305 else {
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
1306 const int a= s->sprite_warping_accuracy;
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
1307 // int l = (1 << (s->f_code - 1)) * 32;
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
1308 mx= RSHIFT(s->sprite_offset[0][0], a-s->quarter_sample);
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
1309 // if (mx < -l) mx= -l;
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
1310 // else if (mx >= l) mx= l-1;
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
1311 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1312 if (mx >= 0xffff)
986e461dc072 Initial revision
glantau
parents:
diff changeset
1313 return -1;
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1314
79
82e579c37bc3 Moved some H.263+ variables to MpegEncContext to be thread-safe.
pulento
parents: 78
diff changeset
1315 if (s->umvplus_dec)
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1316 my = h263p_decode_umotion(s, pred_y);
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
1317 else if(!s->mcsel)
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1318 my = h263_decode_motion(s, pred_y, s->f_code);
255
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
1319 else{
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
1320 const int a= s->sprite_warping_accuracy;
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
1321 // int l = (1 << (s->f_code - 1)) * 32;
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
1322 my= RSHIFT(s->sprite_offset[0][1], a-s->quarter_sample);
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
1323 // if (my < -l) my= -l;
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
1324 // else if (my >= l) my= l-1;
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
1325 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1326 if (my >= 0xffff)
986e461dc072 Initial revision
glantau
parents:
diff changeset
1327 return -1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1328 s->mv[0][0][0] = mx;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1329 s->mv[0][0][1] = my;
154
f914f710b8d0 - Fixed a bug on H.263 MV prediction for MB on GOBs limits.
pulento
parents: 144
diff changeset
1330 /*fprintf(stderr, "\n MB %d", (s->mb_y * s->mb_width) + s->mb_x);
f914f710b8d0 - Fixed a bug on H.263 MV prediction for MB on GOBs limits.
pulento
parents: 144
diff changeset
1331 fprintf(stderr, "\n\tmvx: %d\t\tpredx: %d", mx, pred_x);
f914f710b8d0 - Fixed a bug on H.263 MV prediction for MB on GOBs limits.
pulento
parents: 144
diff changeset
1332 fprintf(stderr, "\n\tmvy: %d\t\tpredy: %d", my, pred_y);*/
79
82e579c37bc3 Moved some H.263+ variables to MpegEncContext to be thread-safe.
pulento
parents: 78
diff changeset
1333 if (s->umvplus_dec && (mx - pred_x) == 1 && (my - pred_y) == 1)
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1334 skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1335
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1336 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1337 s->mv_type = MV_TYPE_8X8;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1338 for(i=0;i<4;i++) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1339 mot_val = h263_pred_motion(s, i, &pred_x, &pred_y);
79
82e579c37bc3 Moved some H.263+ variables to MpegEncContext to be thread-safe.
pulento
parents: 78
diff changeset
1340 if (s->umvplus_dec)
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1341 mx = h263p_decode_umotion(s, pred_x);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1342 else
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1343 mx = h263_decode_motion(s, pred_x, s->f_code);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1344 if (mx >= 0xffff)
986e461dc072 Initial revision
glantau
parents:
diff changeset
1345 return -1;
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1346
79
82e579c37bc3 Moved some H.263+ variables to MpegEncContext to be thread-safe.
pulento
parents: 78
diff changeset
1347 if (s->umvplus_dec)
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1348 my = h263p_decode_umotion(s, pred_y);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1349 else
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1350 my = h263_decode_motion(s, pred_y, s->f_code);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1351 if (my >= 0xffff)
986e461dc072 Initial revision
glantau
parents:
diff changeset
1352 return -1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1353 s->mv[0][i][0] = mx;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1354 s->mv[0][i][1] = my;
79
82e579c37bc3 Moved some H.263+ variables to MpegEncContext to be thread-safe.
pulento
parents: 78
diff changeset
1355 if (s->umvplus_dec && (mx - pred_x) == 1 && (my - pred_y) == 1)
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1356 skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1357 mot_val[0] = mx;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1358 mot_val[1] = my;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1359 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1360 }
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1361 } else if(s->pict_type==B_TYPE) {
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1362 int modb1; // first bit of modb
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1363 int modb2; // second bit of modb
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1364 int mb_type;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1365 int time_pp;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1366 int time_pb;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1367 int xy;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1368
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1369 s->mb_intra = 0; //B-frames never contain intra blocks
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1370 s->mcsel=0; // ... true gmc blocks
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1371
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1372 if(s->mb_x==0){
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1373 s->last_mv[0][0][0]=
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1374 s->last_mv[0][0][1]=
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1375 s->last_mv[1][0][0]=
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1376 s->last_mv[1][0][1]= 0;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1377 }
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1378
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1379 /* if we skipped it in the future P Frame than skip it now too */
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1380 s->mb_skiped= s->mbskip_table[s->mb_y * s->mb_width + s->mb_x]; // Note, skiptab=0 if last was GMC
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1381
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1382 if(s->mb_skiped){
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1383 /* skip mb */
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1384 for(i=0;i<6;i++)
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1385 s->block_last_index[i] = -1;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1386
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1387 s->mv_dir = MV_DIR_FORWARD;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1388 s->mv_type = MV_TYPE_16X16;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1389 s->mv[0][0][0] = 0;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1390 s->mv[0][0][1] = 0;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1391 s->mv[1][0][0] = 0;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1392 s->mv[1][0][1] = 0;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1393 s->last_mv[0][0][0]=
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1394 s->last_mv[0][0][1]=
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1395 s->last_mv[1][0][0]=
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1396 s->last_mv[1][0][1]= 0;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1397 s->mb_skiped = 1;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1398 return 0;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1399 }
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1400
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1401 modb1= get_bits1(&s->gb);
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1402 if(modb1==0){
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1403 modb2= get_bits1(&s->gb);
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1404 mb_type= get_vlc(&s->gb, &mb_type_b_vlc);
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1405 if(modb2==0) cbp= get_bits(&s->gb, 6);
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1406 else cbp=0;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1407 if (mb_type && cbp) {
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1408 if(get_bits1(&s->gb)){
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1409 s->qscale +=get_bits1(&s->gb)*4 - 2;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1410 if (s->qscale < 1)
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1411 s->qscale = 1;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1412 else if (s->qscale > 31)
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1413 s->qscale = 31;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1414 }
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1415 }
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1416 }else{
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1417 mb_type=4; //like 0 but no vectors coded
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1418 cbp=0;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1419 }
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1420 s->mv_type = MV_TYPE_16X16; // we'll switch to 8x8 only if the last P frame had 8x8 for this MB and mb_type=0 here
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1421 mx=my=0; //for case 4, we could put this to the mb_type=4 but than gcc compains about uninitalized mx/my
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1422 switch(mb_type)
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1423 {
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1424 case 0:
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1425 mx = h263_decode_motion(s, 0, 1);
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1426 my = h263_decode_motion(s, 0, 1);
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1427 case 4:
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1428 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
266
252444e5259b optimization
michaelni
parents: 265
diff changeset
1429 xy= s->block_index[0];
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1430 time_pp= s->last_non_b_time[0] - s->last_non_b_time[1];
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1431 time_pb= s->time - s->last_non_b_time[1];
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1432 //if(time_pp>3000 )printf("%d %d ", time_pp, time_pb);
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1433 //FIXME 4MV
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1434 //FIXME avoid divides
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1435 s->mv[0][0][0] = s->motion_val[xy][0]*time_pb/time_pp + mx;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1436 s->mv[0][0][1] = s->motion_val[xy][1]*time_pb/time_pp + my;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1437 s->mv[1][0][0] = mx ? s->mv[0][0][0] - s->motion_val[xy][0]
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1438 : s->motion_val[xy][0]*(time_pb - time_pp)/time_pp + mx;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1439 s->mv[1][0][1] = my ? s->mv[0][0][1] - s->motion_val[xy][1]
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1440 : s->motion_val[xy][1]*(time_pb - time_pp)/time_pp + my;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1441 /* s->mv[0][0][0] =
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1442 s->mv[0][0][1] =
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1443 s->mv[1][0][0] =
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1444 s->mv[1][0][1] = 1000;*/
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1445 break;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1446 case 1:
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1447 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1448 mx = h263_decode_motion(s, s->last_mv[0][0][0], s->f_code);
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1449 my = h263_decode_motion(s, s->last_mv[0][0][1], s->f_code);
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1450 s->last_mv[0][0][0]= s->mv[0][0][0] = mx;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1451 s->last_mv[0][0][1]= s->mv[0][0][1] = my;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1452
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1453 mx = h263_decode_motion(s, s->last_mv[1][0][0], s->b_code);
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1454 my = h263_decode_motion(s, s->last_mv[1][0][1], s->b_code);
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1455 s->last_mv[1][0][0]= s->mv[1][0][0] = mx;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1456 s->last_mv[1][0][1]= s->mv[1][0][1] = my;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1457 break;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1458 case 2:
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1459 s->mv_dir = MV_DIR_BACKWARD;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1460 mx = h263_decode_motion(s, s->last_mv[1][0][0], s->b_code);
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1461 my = h263_decode_motion(s, s->last_mv[1][0][1], s->b_code);
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1462 s->last_mv[1][0][0]= s->mv[1][0][0] = mx;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1463 s->last_mv[1][0][1]= s->mv[1][0][1] = my;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1464 break;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1465 case 3:
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1466 s->mv_dir = MV_DIR_FORWARD;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1467 mx = h263_decode_motion(s, s->last_mv[0][0][0], s->f_code);
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1468 my = h263_decode_motion(s, s->last_mv[0][0][1], s->f_code);
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1469 s->last_mv[0][0][0]= s->mv[0][0][0] = mx;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1470 s->last_mv[0][0][1]= s->mv[0][0][1] = my;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1471 break;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1472 default: return -1;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1473 }
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1474 } else { /* I-Frame */
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1475 cbpc = get_vlc(&s->gb, &intra_MCBPC_vlc);
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1476 if (cbpc < 0)
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1477 return -1;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1478 dquant = cbpc & 4;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1479 s->mb_intra = 1;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1480 intra:
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1481 s->ac_pred = 0;
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1482 if (s->h263_pred || s->h263_aic) {
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
1483 s->ac_pred = get_bits1(&s->gb);
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1484 if (s->ac_pred && s->h263_aic)
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1485 s->h263_aic_dir = get_bits1(&s->gb);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1486 }
249
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1487 if (s->h263_aic) {
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1488 s->y_dc_scale = 2 * s->qscale;
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1489 s->c_dc_scale = 2 * s->qscale;
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1490 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1491 cbpy = get_vlc(&s->gb, &cbpy_vlc);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1492 cbp = (cbpc & 3) | (cbpy << 2);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1493 if (dquant) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1494 s->qscale += quant_tab[get_bits(&s->gb, 2)];
986e461dc072 Initial revision
glantau
parents:
diff changeset
1495 if (s->qscale < 1)
986e461dc072 Initial revision
glantau
parents:
diff changeset
1496 s->qscale = 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1497 else if (s->qscale > 31)
986e461dc072 Initial revision
glantau
parents:
diff changeset
1498 s->qscale = 31;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1499 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1500 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1501
986e461dc072 Initial revision
glantau
parents:
diff changeset
1502 /* decode each block */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1503 if (s->h263_pred) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1504 for (i = 0; i < 6; i++) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1505 if (mpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1) < 0)
986e461dc072 Initial revision
glantau
parents:
diff changeset
1506 return -1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1507 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1508 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1509 for (i = 0; i < 6; i++) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1510 if (h263_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1) < 0)
986e461dc072 Initial revision
glantau
parents:
diff changeset
1511 return -1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1512 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1513 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1514 return 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1515 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1516
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1517 static int h263_decode_motion(MpegEncContext * s, int pred, int f_code)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1518 {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1519 int code, val, sign, shift, l, m;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1520
986e461dc072 Initial revision
glantau
parents:
diff changeset
1521 code = get_vlc(&s->gb, &mv_vlc);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1522 if (code < 0)
986e461dc072 Initial revision
glantau
parents:
diff changeset
1523 return 0xffff;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1524
986e461dc072 Initial revision
glantau
parents:
diff changeset
1525 if (code == 0)
986e461dc072 Initial revision
glantau
parents:
diff changeset
1526 return pred;
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
1527 sign = get_bits1(&s->gb);
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1528 shift = f_code - 1;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1529 val = (code - 1) << shift;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1530 if (shift > 0)
986e461dc072 Initial revision
glantau
parents:
diff changeset
1531 val |= get_bits(&s->gb, shift);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1532 val++;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1533 if (sign)
986e461dc072 Initial revision
glantau
parents:
diff changeset
1534 val = -val;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1535 val += pred;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1536
986e461dc072 Initial revision
glantau
parents:
diff changeset
1537 /* modulo decoding */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1538 if (!s->h263_long_vectors) {
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1539 l = (1 << (f_code - 1)) * 32;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1540 m = 2 * l;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1541 if (val < -l) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1542 val += m;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1543 } else if (val >= l) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1544 val -= m;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1545 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1546 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1547 /* horrible h263 long vector mode */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1548 if (pred < -31 && val < -63)
986e461dc072 Initial revision
glantau
parents:
diff changeset
1549 val += 64;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1550 if (pred > 32 && val > 63)
986e461dc072 Initial revision
glantau
parents:
diff changeset
1551 val -= 64;
154
f914f710b8d0 - Fixed a bug on H.263 MV prediction for MB on GOBs limits.
pulento
parents: 144
diff changeset
1552
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1553 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1554 return val;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1555 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1556
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1557 /* Decodes RVLC of H.263+ UMV */
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1558 static int h263p_decode_umotion(MpegEncContext * s, int pred)
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1559 {
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1560 int code = 0, sign;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1561
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1562 if (get_bits1(&s->gb)) /* Motion difference = 0 */
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1563 return pred;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1564
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1565 code = 2 + get_bits1(&s->gb);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1566
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1567 while (get_bits1(&s->gb))
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1568 {
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1569 code <<= 1;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1570 code += get_bits1(&s->gb);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1571 }
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1572 sign = code & 1;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1573 code >>= 1;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1574
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1575 code = (sign) ? (pred - code) : (pred + code);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1576 #ifdef DEBUG
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1577 fprintf(stderr,"H.263+ UMV Motion = %d\n", code);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1578 #endif
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1579 return code;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1580
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1581 }
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1582
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1583 static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
986e461dc072 Initial revision
glantau
parents:
diff changeset
1584 int n, int coded)
986e461dc072 Initial revision
glantau
parents:
diff changeset
1585 {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1586 int code, level, i, j, last, run;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1587 RLTable *rl = &rl_inter;
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1588 const UINT8 *scan_table;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1589
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1590 scan_table = zigzag_direct;
249
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1591 if (s->h263_aic && s->mb_intra) {
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1592 rl = &rl_intra_aic;
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1593 i = 0;
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1594 if (s->ac_pred) {
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1595 if (s->h263_aic_dir)
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1596 scan_table = ff_alternate_vertical_scan; /* left */
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1597 else
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1598 scan_table = ff_alternate_horizontal_scan; /* top */
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1599 }
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1600 } else if (s->mb_intra) {
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1601 /* DC coef */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1602 if (s->h263_rv10 && s->rv10_version == 3 && s->pict_type == I_TYPE) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1603 int component, diff;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1604 component = (n <= 3 ? 0 : n - 4 + 1);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1605 level = s->last_dc[component];
986e461dc072 Initial revision
glantau
parents:
diff changeset
1606 if (s->rv10_first_dc_coded[component]) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1607 diff = rv_decode_dc(s, n);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1608 if (diff == 0xffff)
986e461dc072 Initial revision
glantau
parents:
diff changeset
1609 return -1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1610 level += diff;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1611 level = level & 0xff; /* handle wrap round */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1612 s->last_dc[component] = level;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1613 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1614 s->rv10_first_dc_coded[component] = 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1615 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1616 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1617 level = get_bits(&s->gb, 8);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1618 if (level == 255)
986e461dc072 Initial revision
glantau
parents:
diff changeset
1619 level = 128;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1620 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1621 block[0] = level;
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1622 i = 1;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1623 } else {
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1624 i = 0;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1625 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1626 if (!coded) {
249
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1627 if (s->mb_intra && s->h263_aic)
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1628 goto not_coded;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1629 s->block_last_index[n] = i - 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1630 return 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1631 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1632
986e461dc072 Initial revision
glantau
parents:
diff changeset
1633 for(;;) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1634 code = get_vlc(&s->gb, &rl->vlc);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1635 if (code < 0)
986e461dc072 Initial revision
glantau
parents:
diff changeset
1636 return -1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1637 if (code == rl->n) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1638 /* escape */
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
1639 last = get_bits1(&s->gb);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1640 run = get_bits(&s->gb, 6);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1641 level = (INT8)get_bits(&s->gb, 8);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1642 if (s->h263_rv10 && level == -128) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1643 /* XXX: should patch encoder too */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1644 level = get_bits(&s->gb, 12);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1645 level = (level << 20) >> 20;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1646 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1647 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1648 run = rl->table_run[code];
986e461dc072 Initial revision
glantau
parents:
diff changeset
1649 level = rl->table_level[code];
986e461dc072 Initial revision
glantau
parents:
diff changeset
1650 last = code >= rl->last;
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
1651 if (get_bits1(&s->gb))
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1652 level = -level;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1653 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1654 i += run;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1655 if (i >= 64)
986e461dc072 Initial revision
glantau
parents:
diff changeset
1656 return -1;
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1657 j = scan_table[i];
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1658 block[j] = level;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1659 if (last)
986e461dc072 Initial revision
glantau
parents:
diff changeset
1660 break;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1661 i++;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1662 }
249
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1663 not_coded:
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1664 if (s->mb_intra && s->h263_aic) {
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1665 h263_pred_acdc(s, block, n);
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1666 i = 63;
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1667 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1668 s->block_last_index[n] = i;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1669 return 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1670 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1671
986e461dc072 Initial revision
glantau
parents:
diff changeset
1672 static int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
986e461dc072 Initial revision
glantau
parents:
diff changeset
1673 {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1674 int level, pred, code;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1675 UINT16 *dc_val;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1676
986e461dc072 Initial revision
glantau
parents:
diff changeset
1677 if (n < 4)
986e461dc072 Initial revision
glantau
parents:
diff changeset
1678 code = get_vlc(&s->gb, &dc_lum);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1679 else
986e461dc072 Initial revision
glantau
parents:
diff changeset
1680 code = get_vlc(&s->gb, &dc_chrom);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1681 if (code < 0)
986e461dc072 Initial revision
glantau
parents:
diff changeset
1682 return -1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1683 if (code == 0) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1684 level = 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1685 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1686 level = get_bits(&s->gb, code);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1687 if ((level >> (code - 1)) == 0) /* if MSB not set it is negative*/
986e461dc072 Initial revision
glantau
parents:
diff changeset
1688 level = - (level ^ ((1 << code) - 1));
986e461dc072 Initial revision
glantau
parents:
diff changeset
1689 if (code > 8)
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
1690 skip_bits1(&s->gb); /* marker */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1691 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1692
986e461dc072 Initial revision
glantau
parents:
diff changeset
1693 pred = mpeg4_pred_dc(s, n, &dc_val, dir_ptr);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1694 level += pred;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1695 if (level < 0)
986e461dc072 Initial revision
glantau
parents:
diff changeset
1696 level = 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1697 if (n < 4) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1698 *dc_val = level * s->y_dc_scale;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1699 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1700 *dc_val = level * s->c_dc_scale;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1701 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1702 return level;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1703 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1704
986e461dc072 Initial revision
glantau
parents:
diff changeset
1705 static int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
986e461dc072 Initial revision
glantau
parents:
diff changeset
1706 int n, int coded)
986e461dc072 Initial revision
glantau
parents:
diff changeset
1707 {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1708 int code, level, i, j, last, run;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1709 int dc_pred_dir;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1710 RLTable *rl;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1711 const UINT8 *scan_table;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1712
986e461dc072 Initial revision
glantau
parents:
diff changeset
1713 if (s->mb_intra) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1714 /* DC coef */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1715 level = mpeg4_decode_dc(s, n, &dc_pred_dir);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1716 if (level < 0)
986e461dc072 Initial revision
glantau
parents:
diff changeset
1717 return -1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1718 block[0] = level;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1719 i = 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1720 if (!coded)
986e461dc072 Initial revision
glantau
parents:
diff changeset
1721 goto not_coded;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1722 rl = &rl_intra;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1723 if (s->ac_pred) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1724 if (dc_pred_dir == 0)
986e461dc072 Initial revision
glantau
parents:
diff changeset
1725 scan_table = ff_alternate_vertical_scan; /* left */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1726 else
986e461dc072 Initial revision
glantau
parents:
diff changeset
1727 scan_table = ff_alternate_horizontal_scan; /* top */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1728 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1729 scan_table = zigzag_direct;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1730 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1731 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1732 i = 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1733 if (!coded) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1734 s->block_last_index[n] = i - 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1735 return 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1736 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1737 rl = &rl_inter;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1738 scan_table = zigzag_direct;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1739 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1740
986e461dc072 Initial revision
glantau
parents:
diff changeset
1741 for(;;) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1742 code = get_vlc(&s->gb, &rl->vlc);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1743 if (code < 0)
986e461dc072 Initial revision
glantau
parents:
diff changeset
1744 return -1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1745 if (code == rl->n) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1746 /* escape */
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
1747 if (get_bits1(&s->gb) != 0) {
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
1748 if (get_bits1(&s->gb) != 0) {
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1749 /* third escape */
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
1750 last = get_bits1(&s->gb);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1751 run = get_bits(&s->gb, 6);
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
1752 get_bits1(&s->gb); /* marker */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1753 level = get_bits(&s->gb, 12);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1754 level = (level << 20) >> 20; /* sign extend */
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
1755 skip_bits1(&s->gb); /* marker */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1756 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1757 /* second escape */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1758 code = get_vlc(&s->gb, &rl->vlc);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1759 if (code < 0 || code >= rl->n)
986e461dc072 Initial revision
glantau
parents:
diff changeset
1760 return -1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1761 run = rl->table_run[code];
986e461dc072 Initial revision
glantau
parents:
diff changeset
1762 level = rl->table_level[code];
986e461dc072 Initial revision
glantau
parents:
diff changeset
1763 last = code >= rl->last;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1764 run += rl->max_run[last][level] + 1;
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
1765 if (get_bits1(&s->gb))
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1766 level = -level;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1767 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1768 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1769 /* first escape */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1770 code = get_vlc(&s->gb, &rl->vlc);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1771 if (code < 0 || code >= rl->n)
986e461dc072 Initial revision
glantau
parents:
diff changeset
1772 return -1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1773 run = rl->table_run[code];
986e461dc072 Initial revision
glantau
parents:
diff changeset
1774 level = rl->table_level[code];
986e461dc072 Initial revision
glantau
parents:
diff changeset
1775 last = code >= rl->last;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1776 level += rl->max_level[last][run];
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
1777 if (get_bits1(&s->gb))
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1778 level = -level;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1779 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1780 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1781 run = rl->table_run[code];
986e461dc072 Initial revision
glantau
parents:
diff changeset
1782 level = rl->table_level[code];
986e461dc072 Initial revision
glantau
parents:
diff changeset
1783 last = code >= rl->last;
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
1784 if (get_bits1(&s->gb))
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1785 level = -level;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1786 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1787 i += run;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1788 if (i >= 64)
986e461dc072 Initial revision
glantau
parents:
diff changeset
1789 return -1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1790 j = scan_table[i];
986e461dc072 Initial revision
glantau
parents:
diff changeset
1791 block[j] = level;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1792 i++;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1793 if (last)
986e461dc072 Initial revision
glantau
parents:
diff changeset
1794 break;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1795 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1796 not_coded:
986e461dc072 Initial revision
glantau
parents:
diff changeset
1797 if (s->mb_intra) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1798 mpeg4_pred_ac(s, block, n, dc_pred_dir);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1799 if (s->ac_pred) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1800 i = 64; /* XXX: not optimal */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1801 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1802 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1803 s->block_last_index[n] = i - 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1804 return 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1805 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1806
986e461dc072 Initial revision
glantau
parents:
diff changeset
1807 /* most is hardcoded. should extend to handle all h263 streams */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1808 int h263_decode_picture_header(MpegEncContext *s)
986e461dc072 Initial revision
glantau
parents:
diff changeset
1809 {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1810 int format, width, height;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1811
986e461dc072 Initial revision
glantau
parents:
diff changeset
1812 /* picture header */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1813 if (get_bits(&s->gb, 22) != 0x20)
986e461dc072 Initial revision
glantau
parents:
diff changeset
1814 return -1;
231
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
1815 s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
1816
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
1817 if (get_bits1(&s->gb) != 1)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1818 return -1; /* marker */
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
1819 if (get_bits1(&s->gb) != 0)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1820 return -1; /* h263 id */
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
1821 skip_bits1(&s->gb); /* split screen off */
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
1822 skip_bits1(&s->gb); /* camera off */
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
1823 skip_bits1(&s->gb); /* freeze picture release off */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1824
155
3c3449bce692 - Bug fix on MV prediction for MPEG4 caused by new H.263 GOB code.
pulento
parents: 154
diff changeset
1825 /* Reset GOB number */
154
f914f710b8d0 - Fixed a bug on H.263 MV prediction for MB on GOBs limits.
pulento
parents: 144
diff changeset
1826 s->gob_number = 0;
155
3c3449bce692 - Bug fix on MV prediction for MPEG4 caused by new H.263 GOB code.
pulento
parents: 154
diff changeset
1827
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1828 format = get_bits(&s->gb, 3);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1829
161
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
1830 if (format != 7 && format != 6) {
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1831 s->h263_plus = 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1832 /* H.263v1 */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1833 width = h263_format[format][0];
986e461dc072 Initial revision
glantau
parents:
diff changeset
1834 height = h263_format[format][1];
986e461dc072 Initial revision
glantau
parents:
diff changeset
1835 if (!width)
986e461dc072 Initial revision
glantau
parents:
diff changeset
1836 return -1;
161
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
1837
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
1838 s->width = width;
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
1839 s->height = height;
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
1840 s->pict_type = I_TYPE + get_bits1(&s->gb);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1841
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
1842 s->unrestricted_mv = get_bits1(&s->gb);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1843 s->h263_long_vectors = s->unrestricted_mv;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1844
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
1845 if (get_bits1(&s->gb) != 0)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1846 return -1; /* SAC: off */
161
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
1847 if (get_bits1(&s->gb) != 0) {
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
1848 s->mv_type = MV_TYPE_8X8; /* Advanced prediction mode */
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
1849 }
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
1850
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
1851 if (get_bits1(&s->gb) != 0)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1852 return -1; /* not PB frame */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1853
986e461dc072 Initial revision
glantau
parents:
diff changeset
1854 s->qscale = get_bits(&s->gb, 5);
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
1855 skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1856 } else {
161
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
1857 int ufep;
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
1858
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1859 /* H.263v2 */
161
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
1860 s->h263_plus = 1;
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
1861 ufep = get_bits(&s->gb, 3); /* Update Full Extended PTYPE */
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
1862
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
1863 if (ufep == 1) {
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
1864 /* OPPTYPE */
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
1865 format = get_bits(&s->gb, 3);
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
1866 skip_bits(&s->gb,1); /* Custom PCF */
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
1867 s->umvplus_dec = get_bits(&s->gb, 1); /* Unrestricted Motion Vector */
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
1868 skip_bits1(&s->gb); /* Syntax-based Arithmetic Coding (SAC) */
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
1869 if (get_bits1(&s->gb) != 0) {
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
1870 s->mv_type = MV_TYPE_8X8; /* Advanced prediction mode */
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
1871 }
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1872 if (get_bits1(&s->gb) != 0) { /* Advanced Intra Coding (AIC) */
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1873 s->h263_aic = 1;
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1874 }
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1875 skip_bits(&s->gb, 7);
161
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
1876 skip_bits(&s->gb, 3); /* Reserved */
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
1877 } else if (ufep != 0)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1878 return -1;
161
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
1879
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1880 /* MPPTYPE */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1881 s->pict_type = get_bits(&s->gb, 3) + 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1882 if (s->pict_type != I_TYPE &&
986e461dc072 Initial revision
glantau
parents:
diff changeset
1883 s->pict_type != P_TYPE)
986e461dc072 Initial revision
glantau
parents:
diff changeset
1884 return -1;
250
3449316664b5 - Bug fix on RTYPE (rounding type) not being honoured by H.263+ decoder.
pulento
parents: 249
diff changeset
1885 skip_bits(&s->gb, 2);
3449316664b5 - Bug fix on RTYPE (rounding type) not being honoured by H.263+ decoder.
pulento
parents: 249
diff changeset
1886 s->no_rounding = get_bits1(&s->gb);
3449316664b5 - Bug fix on RTYPE (rounding type) not being honoured by H.263+ decoder.
pulento
parents: 249
diff changeset
1887 //fprintf(stderr, "\nRTYPE: %d", s->no_rounding);
3449316664b5 - Bug fix on RTYPE (rounding type) not being honoured by H.263+ decoder.
pulento
parents: 249
diff changeset
1888 skip_bits(&s->gb, 4);
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1889
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1890 /* Get the picture dimensions */
161
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
1891 if (ufep) {
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
1892 if (format == 6) {
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
1893 /* Custom Picture Format (CPFMT) */
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
1894 skip_bits(&s->gb, 4); /* aspect ratio */
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
1895 width = (get_bits(&s->gb, 9) + 1) * 4;
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
1896 skip_bits1(&s->gb);
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
1897 height = get_bits(&s->gb, 9) * 4;
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1898 #ifdef DEBUG
161
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
1899 fprintf(stderr,"\nH.263+ Custom picture: %dx%d\n",width,height);
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1900 #endif
161
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
1901 }
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
1902 else {
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
1903 width = h263_format[format][0];
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
1904 height = h263_format[format][1];
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
1905 }
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
1906 if ((width == 0) || (height == 0))
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
1907 return -1;
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
1908 s->width = width;
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
1909 s->height = height;
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
1910 if (s->umvplus_dec) {
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
1911 skip_bits1(&s->gb); /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
1912 }
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1913 }
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1914
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1915 s->qscale = get_bits(&s->gb, 5);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1916 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1917 /* PEI */
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
1918 while (get_bits1(&s->gb) != 0) {
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
1919 skip_bits(&s->gb, 8);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1920 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1921 s->f_code = 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1922 return 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1923 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1924
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
1925 static void mpeg4_decode_sprite_trajectory(MpegEncContext * s)
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
1926 {
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
1927 int i;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
1928 int a= 2<<s->sprite_warping_accuracy;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
1929 int rho= 3-s->sprite_warping_accuracy;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
1930 int r=16/a;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
1931 const int vop_ref[4][2]= {{0,0}, {s->width,0}, {0, s->height}, {s->width, s->height}}; // only true for rectangle shapes
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
1932 int d[4][2]={{0,0}, {0,0}, {0,0}, {0,0}};
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
1933 int sprite_ref[4][2];
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
1934 int virtual_ref[2][2];
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
1935 int w2, h2;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
1936 int alpha=0, beta=0;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
1937 int w= s->width;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
1938 int h= s->height;
255
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
1939 //printf("SP %d\n", s->sprite_warping_accuracy);
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
1940 for(i=0; i<s->num_sprite_warping_points; i++){
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
1941 int length;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
1942 int x=0, y=0;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
1943
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
1944 length= get_vlc(&s->gb, &sprite_trajectory);
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
1945 if(length){
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
1946 x= get_bits(&s->gb, length);
255
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
1947 //printf("lx %d %d\n", length, x);
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
1948 if ((x >> (length - 1)) == 0) /* if MSB not set it is negative*/
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
1949 x = - (x ^ ((1 << length) - 1));
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
1950 }
255
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
1951 if(!(s->divx_version==500 && s->divx_build==413)) skip_bits1(&s->gb); /* marker bit */
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
1952
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
1953 length= get_vlc(&s->gb, &sprite_trajectory);
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
1954 if(length){
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
1955 y=get_bits(&s->gb, length);
255
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
1956 //printf("ly %d %d\n", length, y);
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
1957 if ((y >> (length - 1)) == 0) /* if MSB not set it is negative*/
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
1958 y = - (y ^ ((1 << length) - 1));
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
1959 }
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
1960 skip_bits1(&s->gb); /* marker bit */
255
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
1961 //printf("%d %d %d %d\n", x, y, i, s->sprite_warping_accuracy);
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
1962 //if(i>0 && (x!=0 || y!=0)) printf("AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\n");
255
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
1963 //x=y=0;
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
1964 d[i][0]= x;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
1965 d[i][1]= y;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
1966 }
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
1967
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
1968 while((1<<alpha)<w) alpha++;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
1969 while((1<<beta )<h) beta++; // there seems to be a typo in the mpeg4 std for the definition of w' and h'
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
1970 w2= 1<<alpha;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
1971 h2= 1<<beta;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
1972
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
1973 // Note, the 4th point isnt used for GMC
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1974 if(s->divx_version==500 && s->divx_build==413){
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1975 sprite_ref[0][0]= a*vop_ref[0][0] + d[0][0];
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1976 sprite_ref[0][1]= a*vop_ref[0][1] + d[0][1];
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1977 sprite_ref[1][0]= a*vop_ref[1][0] + d[0][0] + d[1][0];
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1978 sprite_ref[1][1]= a*vop_ref[1][1] + d[0][1] + d[1][1];
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1979 sprite_ref[2][0]= a*vop_ref[2][0] + d[0][0] + d[2][0];
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1980 sprite_ref[2][1]= a*vop_ref[2][1] + d[0][1] + d[2][1];
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1981 } else {
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1982 sprite_ref[0][0]= (a>>1)*(2*vop_ref[0][0] + d[0][0]);
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1983 sprite_ref[0][1]= (a>>1)*(2*vop_ref[0][1] + d[0][1]);
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1984 sprite_ref[1][0]= (a>>1)*(2*vop_ref[1][0] + d[0][0] + d[1][0]);
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1985 sprite_ref[1][1]= (a>>1)*(2*vop_ref[1][1] + d[0][1] + d[1][1]);
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1986 sprite_ref[2][0]= (a>>1)*(2*vop_ref[2][0] + d[0][0] + d[2][0]);
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1987 sprite_ref[2][1]= (a>>1)*(2*vop_ref[2][1] + d[0][1] + d[2][1]);
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1988 }
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
1989 /* sprite_ref[3][0]= (a>>1)*(2*vop_ref[3][0] + d[0][0] + d[1][0] + d[2][0] + d[3][0]);
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
1990 sprite_ref[3][1]= (a>>1)*(2*vop_ref[3][1] + d[0][1] + d[1][1] + d[2][1] + d[3][1]); */
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
1991
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
1992 // this is mostly identical to the mpeg4 std (and is totally unreadable because of that ...)
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
1993 // perhaps it should be reordered to be more readable ...
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
1994 // the idea behind this virtual_ref mess is to be able to use shifts later per pixel instead of divides
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
1995 // so the distance between points is converted from w&h based to w2&h2 based which are of the 2^x form
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
1996 virtual_ref[0][0]= 16*(vop_ref[0][0] + w2)
255
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
1997 + RDIV(((w - w2)*(r*sprite_ref[0][0] - 16*vop_ref[0][0]) + w2*(r*sprite_ref[1][0] - 16*vop_ref[1][0])),w);
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
1998 virtual_ref[0][1]= 16*vop_ref[0][1]
255
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
1999 + RDIV(((w - w2)*(r*sprite_ref[0][1] - 16*vop_ref[0][1]) + w2*(r*sprite_ref[1][1] - 16*vop_ref[1][1])),w);
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
2000 virtual_ref[1][0]= 16*vop_ref[0][0]
255
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
2001 + RDIV(((h - h2)*(r*sprite_ref[0][0] - 16*vop_ref[0][0]) + h2*(r*sprite_ref[2][0] - 16*vop_ref[2][0])),h);
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
2002 virtual_ref[1][1]= 16*(vop_ref[0][1] + h2)
255
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
2003 + RDIV(((h - h2)*(r*sprite_ref[0][1] - 16*vop_ref[0][1]) + h2*(r*sprite_ref[2][1] - 16*vop_ref[2][1])),h);
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
2004
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
2005 switch(s->num_sprite_warping_points)
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
2006 {
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
2007 case 0:
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
2008 s->sprite_offset[0][0]= 0;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
2009 s->sprite_offset[0][1]= 0;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
2010 s->sprite_offset[1][0]= 0;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
2011 s->sprite_offset[1][1]= 0;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
2012 s->sprite_delta[0][0][0]= a;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
2013 s->sprite_delta[0][0][1]= 0;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
2014 s->sprite_delta[0][1][0]= 0;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
2015 s->sprite_delta[0][1][1]= a;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
2016 s->sprite_delta[1][0][0]= a;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
2017 s->sprite_delta[1][0][1]= 0;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
2018 s->sprite_delta[1][1][0]= 0;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
2019 s->sprite_delta[1][1][1]= a;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
2020 s->sprite_shift[0][0]= 0;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
2021 s->sprite_shift[0][1]= 0;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
2022 s->sprite_shift[1][0]= 0;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
2023 s->sprite_shift[1][1]= 0;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
2024 break;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
2025 case 1: //GMC only
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
2026 s->sprite_offset[0][0]= sprite_ref[0][0] - a*vop_ref[0][0];
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
2027 s->sprite_offset[0][1]= sprite_ref[0][1] - a*vop_ref[0][1];
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
2028 s->sprite_offset[1][0]= ((sprite_ref[0][0]>>1)|(sprite_ref[0][0]&1)) - a*(vop_ref[0][0]/2);
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
2029 s->sprite_offset[1][1]= ((sprite_ref[0][1]>>1)|(sprite_ref[0][1]&1)) - a*(vop_ref[0][1]/2);
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
2030 s->sprite_delta[0][0][0]= a;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
2031 s->sprite_delta[0][0][1]= 0;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
2032 s->sprite_delta[0][1][0]= 0;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
2033 s->sprite_delta[0][1][1]= a;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
2034 s->sprite_delta[1][0][0]= a;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
2035 s->sprite_delta[1][0][1]= 0;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
2036 s->sprite_delta[1][1][0]= 0;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
2037 s->sprite_delta[1][1][1]= a;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
2038 s->sprite_shift[0][0]= 0;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
2039 s->sprite_shift[0][1]= 0;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
2040 s->sprite_shift[1][0]= 0;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
2041 s->sprite_shift[1][1]= 0;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
2042 break;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
2043 case 2:
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
2044 case 3: //FIXME
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
2045 s->sprite_offset[0][0]= (sprite_ref[0][0]<<(alpha+rho))
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
2046 + ((-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][0])
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
2047 +( r*sprite_ref[0][1] - virtual_ref[0][1])*(-vop_ref[0][1]));
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
2048 s->sprite_offset[0][1]= (sprite_ref[0][1]<<(alpha+rho))
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
2049 + ((-r*sprite_ref[0][1] + virtual_ref[0][1])*(-vop_ref[0][0])
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
2050 +(-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][1]));
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
2051 s->sprite_offset[1][0]= ((-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][0] + 1)
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
2052 +( r*sprite_ref[0][1] - virtual_ref[0][1])*(-2*vop_ref[0][1] + 1)
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
2053 +2*w2*r*sprite_ref[0][0] - 16*w2);
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
2054 s->sprite_offset[1][1]= ((-r*sprite_ref[0][1] + virtual_ref[0][1])*(-2*vop_ref[0][0] + 1)
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
2055 +(-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][1] + 1)
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
2056 +2*w2*r*sprite_ref[0][1] - 16*w2);
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
2057 s->sprite_delta[0][0][0]= (-r*sprite_ref[0][0] + virtual_ref[0][0]);
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
2058 s->sprite_delta[0][0][1]= ( r*sprite_ref[0][1] - virtual_ref[0][1]);
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
2059 s->sprite_delta[0][1][0]= (-r*sprite_ref[0][1] + virtual_ref[0][1]);
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
2060 s->sprite_delta[0][1][1]= (-r*sprite_ref[0][0] + virtual_ref[0][0]);
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
2061 s->sprite_delta[1][0][0]= 4*(-r*sprite_ref[0][0] + virtual_ref[0][0]);
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
2062 s->sprite_delta[1][0][1]= 4*( r*sprite_ref[0][1] - virtual_ref[0][1]);
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
2063 s->sprite_delta[1][1][0]= 4*(-r*sprite_ref[0][1] + virtual_ref[0][1]);
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
2064 s->sprite_delta[1][1][1]= 4*(-r*sprite_ref[0][0] + virtual_ref[0][0]);
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
2065 s->sprite_shift[0][0]= alpha+rho;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
2066 s->sprite_shift[0][1]= alpha+rho;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
2067 s->sprite_shift[1][0]= alpha+rho+2;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
2068 s->sprite_shift[1][1]= alpha+rho+2;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
2069 break;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
2070 // case 3:
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
2071 break;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
2072 }
255
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
2073 /*printf("%d %d\n", s->sprite_delta[0][0][0], a<<s->sprite_shift[0][0]);
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
2074 printf("%d %d\n", s->sprite_delta[0][0][1], 0);
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
2075 printf("%d %d\n", s->sprite_delta[0][1][0], 0);
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
2076 printf("%d %d\n", s->sprite_delta[0][1][1], a<<s->sprite_shift[0][1]);
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
2077 printf("%d %d\n", s->sprite_delta[1][0][0], a<<s->sprite_shift[1][0]);
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
2078 printf("%d %d\n", s->sprite_delta[1][0][1], 0);
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
2079 printf("%d %d\n", s->sprite_delta[1][1][0], 0);
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
2080 printf("%d %d\n", s->sprite_delta[1][1][1], a<<s->sprite_shift[1][1]);*/
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
2081 /* try to simplify the situation */
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
2082 if( s->sprite_delta[0][0][0] == a<<s->sprite_shift[0][0]
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
2083 && s->sprite_delta[0][0][1] == 0
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
2084 && s->sprite_delta[0][1][0] == 0
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
2085 && s->sprite_delta[0][1][1] == a<<s->sprite_shift[0][1]
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
2086 && s->sprite_delta[1][0][0] == a<<s->sprite_shift[1][0]
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
2087 && s->sprite_delta[1][0][1] == 0
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
2088 && s->sprite_delta[1][1][0] == 0
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
2089 && s->sprite_delta[1][1][1] == a<<s->sprite_shift[1][1])
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
2090 {
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
2091 s->sprite_offset[0][0]>>=s->sprite_shift[0][0];
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
2092 s->sprite_offset[0][1]>>=s->sprite_shift[0][1];
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
2093 s->sprite_offset[1][0]>>=s->sprite_shift[1][0];
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
2094 s->sprite_offset[1][1]>>=s->sprite_shift[1][1];
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
2095 s->sprite_delta[0][0][0]= a;
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
2096 s->sprite_delta[0][0][1]= 0;
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
2097 s->sprite_delta[0][1][0]= 0;
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
2098 s->sprite_delta[0][1][1]= a;
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
2099 s->sprite_delta[1][0][0]= a;
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
2100 s->sprite_delta[1][0][1]= 0;
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
2101 s->sprite_delta[1][1][0]= 0;
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
2102 s->sprite_delta[1][1][1]= a;
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
2103 s->sprite_shift[0][0]= 0;
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
2104 s->sprite_shift[0][1]= 0;
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
2105 s->sprite_shift[1][0]= 0;
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
2106 s->sprite_shift[1][1]= 0;
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
2107 s->real_sprite_warping_points=1;
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
2108 }
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
2109 else
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
2110 s->real_sprite_warping_points= s->num_sprite_warping_points;
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
2111
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
2112 }
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
2113
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2114 /* decode mpeg4 VOP header */
986e461dc072 Initial revision
glantau
parents:
diff changeset
2115 int mpeg4_decode_picture_header(MpegEncContext * s)
986e461dc072 Initial revision
glantau
parents:
diff changeset
2116 {
986e461dc072 Initial revision
glantau
parents:
diff changeset
2117 int time_incr, startcode, state, v;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2118
986e461dc072 Initial revision
glantau
parents:
diff changeset
2119 redo:
986e461dc072 Initial revision
glantau
parents:
diff changeset
2120 /* search next start code */
986e461dc072 Initial revision
glantau
parents:
diff changeset
2121 align_get_bits(&s->gb);
986e461dc072 Initial revision
glantau
parents:
diff changeset
2122 state = 0xff;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2123 for(;;) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
2124 v = get_bits(&s->gb, 8);
986e461dc072 Initial revision
glantau
parents:
diff changeset
2125 if (state == 0x000001) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
2126 state = ((state << 8) | v) & 0xffffff;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2127 startcode = state;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2128 break;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2129 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
2130 state = ((state << 8) | v) & 0xffffff;
278
michaelni
parents: 277
diff changeset
2131 if( get_bits_count(&s->gb) > s->gb.size*8-32){
277
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
2132 printf("no VOP startcode found\n");
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2133 return -1;
263
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
2134 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2135 }
253
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
2136 //printf("startcode %X %d\n", startcode, get_bits_count(&s->gb));
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
2137 if (startcode == 0x120) { // Video Object Layer
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2138 int width, height, vo_ver_id;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2139
986e461dc072 Initial revision
glantau
parents:
diff changeset
2140 /* vol header */
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
2141 skip_bits(&s->gb, 1); /* random access */
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
2142 skip_bits(&s->gb, 8); /* vo_type */
63
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
2143 if (get_bits1(&s->gb) != 0) { /* is_ol_id */
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
2144 vo_ver_id = get_bits(&s->gb, 4); /* vo_ver_id */
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
2145 skip_bits(&s->gb, 3); /* vo_priority */
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
2146 } else {
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
2147 vo_ver_id = 1;
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
2148 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2149
253
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
2150 s->aspect_ratio_info= get_bits(&s->gb, 4);
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
2151 if(s->aspect_ratio_info == EXTENDET_PAR){
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
2152 skip_bits(&s->gb, 8); //par_width
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
2153 skip_bits(&s->gb, 8); // par_height
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
2154 }
281
1fc96b02142e mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents: 278
diff changeset
2155
253
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
2156 if(get_bits1(&s->gb)){ /* vol control parameter */
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
2157 printf("vol control parameter not supported\n");
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
2158 return -1;
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
2159 }
63
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
2160 s->shape = get_bits(&s->gb, 2); /* vol shape */
264
28c5c62b1c4c support decoding (with mplayer) of 3 .mp4 files from mphq
michaelni
parents: 263
diff changeset
2161 if(s->shape != RECT_SHAPE) printf("only rectangular vol supported\n");
253
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
2162 if(s->shape == GRAY_SHAPE && vo_ver_id != 1){
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
2163 printf("Gray shape not supported\n");
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
2164 skip_bits(&s->gb, 4); //video_object_layer_shape_extension
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
2165 }
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
2166
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
2167 skip_bits1(&s->gb); /* marker */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2168
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2169 s->time_increment_resolution = get_bits(&s->gb, 16);
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2170 s->time_increment_bits = av_log2(s->time_increment_resolution - 1) + 1;
63
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
2171 if (s->time_increment_bits < 1)
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
2172 s->time_increment_bits = 1;
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
2173 skip_bits1(&s->gb); /* marker */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2174
63
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
2175 if (get_bits1(&s->gb) != 0) { /* fixed_vop_rate */
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
2176 skip_bits(&s->gb, s->time_increment_bits);
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
2177 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2178
253
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
2179 if (s->shape != BIN_ONLY_SHAPE) {
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
2180 if (s->shape == RECT_SHAPE) {
63
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
2181 skip_bits1(&s->gb); /* marker */
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
2182 width = get_bits(&s->gb, 13);
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
2183 skip_bits1(&s->gb); /* marker */
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
2184 height = get_bits(&s->gb, 13);
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
2185 skip_bits1(&s->gb); /* marker */
274
d0c186bcf075 use the width & height from the mpeg4 header ... in the case that its complete
michaelni
parents: 272
diff changeset
2186 if(width && height){ /* they should be non zero but who knows ... */
d0c186bcf075 use the width & height from the mpeg4 header ... in the case that its complete
michaelni
parents: 272
diff changeset
2187 s->width = width;
d0c186bcf075 use the width & height from the mpeg4 header ... in the case that its complete
michaelni
parents: 272
diff changeset
2188 s->height = height;
277
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
2189 // printf("%d %d\n", width, height);
274
d0c186bcf075 use the width & height from the mpeg4 header ... in the case that its complete
michaelni
parents: 272
diff changeset
2190 }
63
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
2191 }
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
2192
264
28c5c62b1c4c support decoding (with mplayer) of 3 .mp4 files from mphq
michaelni
parents: 263
diff changeset
2193 if(get_bits1(&s->gb)) printf("interlaced not supported\n"); /* interlaced */
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
2194 if(!get_bits1(&s->gb)) printf("OBMC not supported\n"); /* OBMC Disable */
63
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
2195 if (vo_ver_id == 1) {
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
2196 s->vol_sprite_usage = get_bits1(&s->gb); /* vol_sprite_usage */
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
2197 } else {
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
2198 s->vol_sprite_usage = get_bits(&s->gb, 2); /* vol_sprite_usage */
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
2199 }
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
2200 if(s->vol_sprite_usage==STATIC_SPRITE) printf("Static Sprites not supported\n");
253
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
2201 if(s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE){
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
2202 if(s->vol_sprite_usage==STATIC_SPRITE){
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
2203 s->sprite_width = get_bits(&s->gb, 13);
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
2204 skip_bits1(&s->gb); /* marker */
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
2205 s->sprite_height= get_bits(&s->gb, 13);
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
2206 skip_bits1(&s->gb); /* marker */
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
2207 s->sprite_left = get_bits(&s->gb, 13);
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
2208 skip_bits1(&s->gb); /* marker */
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
2209 s->sprite_top = get_bits(&s->gb, 13);
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
2210 skip_bits1(&s->gb); /* marker */
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
2211 }
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
2212 s->num_sprite_warping_points= get_bits(&s->gb, 6);
253
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
2213 s->sprite_warping_accuracy = get_bits(&s->gb, 2);
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
2214 s->sprite_brightness_change= get_bits1(&s->gb);
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
2215 if(s->vol_sprite_usage==STATIC_SPRITE)
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
2216 s->low_latency_sprite= get_bits1(&s->gb);
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
2217 }
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
2218 // FIXME sadct disable bit if verid!=1 && shape not rect
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
2219
63
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
2220 if (get_bits1(&s->gb) == 1) { /* not_8_bit */
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
2221 s->quant_precision = get_bits(&s->gb, 4); /* quant_precision */
264
28c5c62b1c4c support decoding (with mplayer) of 3 .mp4 files from mphq
michaelni
parents: 263
diff changeset
2222 if(get_bits(&s->gb, 4)!=8) printf("N-bit not supported\n"); /* bits_per_pixel */
63
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
2223 } else {
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
2224 s->quant_precision = 5;
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
2225 }
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
2226
253
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
2227 // FIXME a bunch of grayscale shape things
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
2228 if(get_bits1(&s->gb)) printf("Quant-Type not supported\n"); /* vol_quant_type */ //FIXME
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
2229 if(vo_ver_id != 1)
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
2230 s->quarter_sample= get_bits1(&s->gb);
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
2231 else s->quarter_sample=0;
264
28c5c62b1c4c support decoding (with mplayer) of 3 .mp4 files from mphq
michaelni
parents: 263
diff changeset
2232
28c5c62b1c4c support decoding (with mplayer) of 3 .mp4 files from mphq
michaelni
parents: 263
diff changeset
2233 if(!get_bits1(&s->gb)) printf("Complexity estimation not supported\n");
253
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
2234 #if 0
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
2235 if(get_bits1(&s->gb)) printf("resync disable\n");
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
2236 #else
63
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
2237 skip_bits1(&s->gb); /* resync_marker_disabled */
253
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
2238 #endif
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
2239 s->data_partioning= get_bits1(&s->gb);
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
2240 if(s->data_partioning){
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
2241 printf("data partitioning not supported\n");
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
2242 skip_bits1(&s->gb); // reversible vlc
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
2243 }
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
2244
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
2245 if(vo_ver_id != 1) {
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
2246 s->new_pred= get_bits1(&s->gb);
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
2247 if(s->new_pred){
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
2248 printf("new pred not supported\n");
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
2249 skip_bits(&s->gb, 2); /* requested upstream message type */
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
2250 skip_bits1(&s->gb); /* newpred segment type */
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
2251 }
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
2252 s->reduced_res_vop= get_bits1(&s->gb);
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
2253 if(s->reduced_res_vop) printf("reduced resolution VOP not supported\n");
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
2254 }
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
2255 else{
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
2256 s->new_pred=0;
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
2257 s->reduced_res_vop= 0;
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
2258 }
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
2259
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
2260 s->scalability= get_bits1(&s->gb);
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
2261 if (s->scalability) {
285
39b78867b71f dont return -1 if mpeg4 scalability ...
michaelni
parents: 283
diff changeset
2262 printf("scalability not supported\n");
63
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
2263 }
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
2264 }
253
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
2265 //printf("end Data %X %d\n", show_bits(&s->gb, 32), get_bits_count(&s->gb)&0x7);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2266 goto redo;
253
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
2267 } else if (startcode == 0x1b2) { //userdata
255
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
2268 char buf[256];
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
2269 int i;
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
2270 int e;
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
2271 int ver, build;
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
2272
253
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
2273 //printf("user Data %X\n", show_bits(&s->gb, 32));
255
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
2274 buf[0]= show_bits(&s->gb, 8);
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
2275 for(i=1; i<256; i++){
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
2276 buf[i]= show_bits(&s->gb, 16)&0xFF;
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
2277 if(buf[i]==0) break;
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
2278 skip_bits(&s->gb, 8);
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
2279 }
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
2280 buf[255]=0;
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
2281 e=sscanf(buf, "DivX%dBuild%d", &ver, &build);
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
2282 if(e==2){
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
2283 s->divx_version= ver;
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
2284 s->divx_build= build;
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
2285 if(s->picture_number==0){
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
2286 printf("This file was encoded with DivX%d Build%d\n", ver, build);
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
2287 if(ver==500 && build==413){ //most likely all version are indeed totally buggy but i dunno for sure ...
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
2288 printf("WARNING: this version of DivX is not MPEG4 compatible, trying to workaround these bugs...\n");
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
2289 }else{
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
2290 printf("hmm, i havnt seen that version of divx yet, lets assume they fixed these bugs ...\n"
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
2291 "using mpeg4 decoder, if it fails contact the developers (of ffmpeg)\n");
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
2292 }
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
2293 }
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
2294 }
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
2295 //printf("User Data: %s\n", buf);
253
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
2296 goto redo;
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
2297 } else if (startcode != 0x1b6) { //VOP
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2298 goto redo;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2299 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
2300
986e461dc072 Initial revision
glantau
parents:
diff changeset
2301 s->pict_type = get_bits(&s->gb, 2) + 1; /* pict type: I = 0 , P = 1 */
264
28c5c62b1c4c support decoding (with mplayer) of 3 .mp4 files from mphq
michaelni
parents: 263
diff changeset
2302 //printf("pic: %d\n", s->pict_type);
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2303 time_incr=0;
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
2304 while (get_bits1(&s->gb) != 0)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2305 time_incr++;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2306
264
28c5c62b1c4c support decoding (with mplayer) of 3 .mp4 files from mphq
michaelni
parents: 263
diff changeset
2307 check_marker(&s->gb, "before time_increment");
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2308 s->time_increment= get_bits(&s->gb, s->time_increment_bits);
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2309 if(s->pict_type!=B_TYPE){
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2310 s->time_base+= time_incr;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2311 s->last_non_b_time[1]= s->last_non_b_time[0];
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2312 s->last_non_b_time[0]= s->time_base*s->time_increment_resolution + s->time_increment;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2313 }else{
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2314 s->time= (s->last_non_b_time[1]/s->time_increment_resolution + time_incr)*s->time_increment_resolution;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2315 s->time+= s->time_increment;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2316 }
264
28c5c62b1c4c support decoding (with mplayer) of 3 .mp4 files from mphq
michaelni
parents: 263
diff changeset
2317
28c5c62b1c4c support decoding (with mplayer) of 3 .mp4 files from mphq
michaelni
parents: 263
diff changeset
2318 if(check_marker(&s->gb, "before vop_coded")==0 && s->picture_number==0){
28c5c62b1c4c support decoding (with mplayer) of 3 .mp4 files from mphq
michaelni
parents: 263
diff changeset
2319 printf("hmm, seems the headers arnt complete, trying to guess time_increment_bits\n");
28c5c62b1c4c support decoding (with mplayer) of 3 .mp4 files from mphq
michaelni
parents: 263
diff changeset
2320 for(s->time_increment_bits++ ;s->time_increment_bits<16; s->time_increment_bits++){
28c5c62b1c4c support decoding (with mplayer) of 3 .mp4 files from mphq
michaelni
parents: 263
diff changeset
2321 if(get_bits1(&s->gb)) break;
28c5c62b1c4c support decoding (with mplayer) of 3 .mp4 files from mphq
michaelni
parents: 263
diff changeset
2322 }
28c5c62b1c4c support decoding (with mplayer) of 3 .mp4 files from mphq
michaelni
parents: 263
diff changeset
2323 printf("my guess is %d bits ;)\n",s->time_increment_bits);
28c5c62b1c4c support decoding (with mplayer) of 3 .mp4 files from mphq
michaelni
parents: 263
diff changeset
2324 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2325 /* vop coded */
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
2326 if (get_bits1(&s->gb) != 1)
63
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
2327 goto redo;
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2328 //printf("time %d %d %d || %d %d %d\n", s->time_increment_bits, s->time_increment, s->time_base,
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2329 //s->time, s->last_non_b_time[0], s->last_non_b_time[1]);
253
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
2330 if (s->shape != BIN_ONLY_SHAPE && ( s->pict_type == P_TYPE
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
2331 || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE))) {
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2332 /* rounding type for motion estimation */
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
2333 s->no_rounding = get_bits1(&s->gb);
63
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
2334 } else {
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
2335 s->no_rounding = 0;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2336 }
253
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
2337 //FIXME reduced res stuff
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
2338
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
2339 if (s->shape != RECT_SHAPE) {
63
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
2340 if (s->vol_sprite_usage != 1 || s->pict_type != I_TYPE) {
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
2341 int width, height, hor_spat_ref, ver_spat_ref;
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
2342
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
2343 width = get_bits(&s->gb, 13);
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
2344 skip_bits1(&s->gb); /* marker */
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
2345 height = get_bits(&s->gb, 13);
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
2346 skip_bits1(&s->gb); /* marker */
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
2347 hor_spat_ref = get_bits(&s->gb, 13); /* hor_spat_ref */
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
2348 skip_bits1(&s->gb); /* marker */
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
2349 ver_spat_ref = get_bits(&s->gb, 13); /* ver_spat_ref */
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
2350 }
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
2351 skip_bits1(&s->gb); /* change_CR_disable */
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
2352
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
2353 if (get_bits1(&s->gb) != 0) {
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
2354 skip_bits(&s->gb, 8); /* constant_alpha_value */
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
2355 }
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
2356 }
253
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
2357 //FIXME complexity estimation stuff
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
2358
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
2359 if (s->shape != BIN_ONLY_SHAPE) {
63
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
2360 skip_bits(&s->gb, 3); /* intra dc VLC threshold */
253
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
2361 //FIXME interlaced specific bits
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
2362 }
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
2363
253
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
2364 if(s->pict_type == S_TYPE && (s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE)){
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
2365 if(s->num_sprite_warping_points){
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
2366 mpeg4_decode_sprite_trajectory(s);
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
2367 }
253
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
2368 if(s->sprite_brightness_change) printf("sprite_brightness_change not supported\n");
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
2369 if(s->vol_sprite_usage==STATIC_SPRITE) printf("static sprite not supported\n");
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
2370 }
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
2371
253
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
2372 if (s->shape != BIN_ONLY_SHAPE) {
63
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
2373 /* note: we do not use quant_precision to avoid problem if no
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
2374 MPEG4 vol header as it is found on some old opendivx
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
2375 movies */
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
2376 s->qscale = get_bits(&s->gb, 5);
264
28c5c62b1c4c support decoding (with mplayer) of 3 .mp4 files from mphq
michaelni
parents: 263
diff changeset
2377 if(s->qscale==0){
28c5c62b1c4c support decoding (with mplayer) of 3 .mp4 files from mphq
michaelni
parents: 263
diff changeset
2378 printf("Error, header damaged or not MPEG4 header (qscale=0)\n");
28c5c62b1c4c support decoding (with mplayer) of 3 .mp4 files from mphq
michaelni
parents: 263
diff changeset
2379 return -1; // makes no sense to continue, as there is nothing left from the image then
28c5c62b1c4c support decoding (with mplayer) of 3 .mp4 files from mphq
michaelni
parents: 263
diff changeset
2380 }
63
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
2381
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
2382 if (s->pict_type != I_TYPE) {
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
2383 s->f_code = get_bits(&s->gb, 3); /* fcode_for */
264
28c5c62b1c4c support decoding (with mplayer) of 3 .mp4 files from mphq
michaelni
parents: 263
diff changeset
2384 if(s->f_code==0){
28c5c62b1c4c support decoding (with mplayer) of 3 .mp4 files from mphq
michaelni
parents: 263
diff changeset
2385 printf("Error, header damaged or not MPEG4 header (f_code=0)\n");
28c5c62b1c4c support decoding (with mplayer) of 3 .mp4 files from mphq
michaelni
parents: 263
diff changeset
2386 return -1; // makes no sense to continue, as the MV decoding will break very quickly
28c5c62b1c4c support decoding (with mplayer) of 3 .mp4 files from mphq
michaelni
parents: 263
diff changeset
2387 }
63
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
2388 }
253
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
2389 if (s->pict_type == B_TYPE) {
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
2390 s->b_code = get_bits(&s->gb, 3);
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2391 //printf("b-code %d\n", s->b_code);
253
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
2392 }
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
2393 //printf("quant:%d fcode:%d\n", s->qscale, s->f_code);
253
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
2394 if(!s->scalability){
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
2395 if (s->shape!=RECT_SHAPE && s->pict_type!=I_TYPE) {
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
2396 skip_bits1(&s->gb); // vop shape coding type
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
2397 }
63
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
2398 }
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
2399 }
255
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
2400 s->picture_number++; // better than pic number==0 allways ;)
63
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
2401 return 0;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2402 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
2403
986e461dc072 Initial revision
glantau
parents:
diff changeset
2404 /* don't understand why they choose a different header ! */
986e461dc072 Initial revision
glantau
parents:
diff changeset
2405 int intel_h263_decode_picture_header(MpegEncContext *s)
986e461dc072 Initial revision
glantau
parents:
diff changeset
2406 {
986e461dc072 Initial revision
glantau
parents:
diff changeset
2407 int format;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2408
986e461dc072 Initial revision
glantau
parents:
diff changeset
2409 /* picture header */
986e461dc072 Initial revision
glantau
parents:
diff changeset
2410 if (get_bits(&s->gb, 22) != 0x20)
986e461dc072 Initial revision
glantau
parents:
diff changeset
2411 return -1;
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
2412 skip_bits(&s->gb, 8); /* picture timestamp */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2413
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
2414 if (get_bits1(&s->gb) != 1)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2415 return -1; /* marker */
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
2416 if (get_bits1(&s->gb) != 0)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2417 return -1; /* h263 id */
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
2418 skip_bits1(&s->gb); /* split screen off */
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
2419 skip_bits1(&s->gb); /* camera off */
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
2420 skip_bits1(&s->gb); /* freeze picture release off */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2421
986e461dc072 Initial revision
glantau
parents:
diff changeset
2422 format = get_bits(&s->gb, 3);
986e461dc072 Initial revision
glantau
parents:
diff changeset
2423 if (format != 7)
986e461dc072 Initial revision
glantau
parents:
diff changeset
2424 return -1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2425
986e461dc072 Initial revision
glantau
parents:
diff changeset
2426 s->h263_plus = 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2427
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
2428 s->pict_type = I_TYPE + get_bits1(&s->gb);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2429
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
2430 s->unrestricted_mv = get_bits1(&s->gb);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2431 s->h263_long_vectors = s->unrestricted_mv;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2432
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
2433 if (get_bits1(&s->gb) != 0)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2434 return -1; /* SAC: off */
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
2435 if (get_bits1(&s->gb) != 0)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2436 return -1; /* advanced prediction mode: off */
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
2437 if (get_bits1(&s->gb) != 0)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2438 return -1; /* not PB frame */
986e461dc072 Initial revision
glantau
parents:
diff changeset
2439
986e461dc072 Initial revision
glantau
parents:
diff changeset
2440 /* skip unknown header garbage */
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
2441 skip_bits(&s->gb, 41);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2442
986e461dc072 Initial revision
glantau
parents:
diff changeset
2443 s->qscale = get_bits(&s->gb, 5);
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
2444 skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2445
986e461dc072 Initial revision
glantau
parents:
diff changeset
2446 /* PEI */
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
2447 while (get_bits1(&s->gb) != 0) {
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
2448 skip_bits(&s->gb, 8);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2449 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
2450 s->f_code = 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2451 return 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2452 }
144
cb5dabd00ba2 - Bug fix on inter MCBPC table for inter+q.
pulento
parents: 110
diff changeset
2453