annotate h263.c @ 327:d359db02fc90 libavcodec

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