annotate h263.c @ 600:b684f0f9ff72 libavcodec

1000l
author michael
date Thu, 08 Aug 2002 10:46:16 +0000
parents b1a191202f96
children df2102629fef
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
429
718a22dc121f license/copyright change
glantau
parents: 396
diff changeset
3 * Copyright (c) 2000,2001 Fabrice Bellard.
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 *
429
718a22dc121f license/copyright change
glantau
parents: 396
diff changeset
7 * This library is free software; you can redistribute it and/or
718a22dc121f license/copyright change
glantau
parents: 396
diff changeset
8 * modify it under the terms of the GNU Lesser General Public
718a22dc121f license/copyright change
glantau
parents: 396
diff changeset
9 * License as published by the Free Software Foundation; either
718a22dc121f license/copyright change
glantau
parents: 396
diff changeset
10 * version 2 of the License, or (at your option) any later version.
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
11 *
429
718a22dc121f license/copyright change
glantau
parents: 396
diff changeset
12 * This library is distributed in the hope that it will be useful,
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
429
718a22dc121f license/copyright change
glantau
parents: 396
diff changeset
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
718a22dc121f license/copyright change
glantau
parents: 396
diff changeset
15 * Lesser General Public License for more details.
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
16 *
429
718a22dc121f license/copyright change
glantau
parents: 396
diff changeset
17 * You should have received a copy of the GNU Lesser General Public
718a22dc121f license/copyright change
glantau
parents: 396
diff changeset
18 * License along with this library; if not, write to the Free Software
718a22dc121f license/copyright change
glantau
parents: 396
diff changeset
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 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 */
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
23
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
24 //#define DEBUG
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
25 #include "common.h"
986e461dc072 Initial revision
glantau
parents:
diff changeset
26 #include "dsputil.h"
986e461dc072 Initial revision
glantau
parents:
diff changeset
27 #include "avcodec.h"
986e461dc072 Initial revision
glantau
parents:
diff changeset
28 #include "mpegvideo.h"
986e461dc072 Initial revision
glantau
parents:
diff changeset
29 #include "h263data.h"
986e461dc072 Initial revision
glantau
parents:
diff changeset
30 #include "mpeg4data.h"
986e461dc072 Initial revision
glantau
parents:
diff changeset
31
255
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
32 //rounded divison & shift
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
33 #define RSHIFT(a,b) ((a) > 0 ? ((a) + (1<<((b)-1)))>>(b) : ((a) + (1<<((b)-1))-1)>>(b))
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
34
523
c7e4c8b9a3c4 warning fix patch by atmos
michaelni
parents: 498
diff changeset
35 #define PRINT_MB_TYPE(a) {}
c7e4c8b9a3c4 warning fix patch by atmos
michaelni
parents: 498
diff changeset
36 //#define PRINT_MB_TYPE(a) printf(a)
359
df0736462b9f move ABS() to common.h
michaelni
parents: 358
diff changeset
37
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
38 #define INTRA_MCBPC_VLC_BITS 6
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
39 #define INTER_MCBPC_VLC_BITS 6
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
40 #define CBPY_VLC_BITS 6
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
41 #define MV_VLC_BITS 9
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
42 #define DC_VLC_BITS 9
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
43 #define SPRITE_TRAJ_VLC_BITS 6
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
44 #define MB_TYPE_B_VLC_BITS 4
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
45 #define TEX_VLC_BITS 9
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
46
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
47 static void h263_encode_block(MpegEncContext * s, DCTELEM * block,
986e461dc072 Initial revision
glantau
parents:
diff changeset
48 int n);
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
49 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
50 static void h263p_encode_umotion(MpegEncContext * s, int val);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
51 static void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block,
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
52 int n, int dc, UINT8 *scan_table,
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
53 PutBitContext *dc_pb, PutBitContext *ac_pb);
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
54 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
55 static int h263p_decode_umotion(MpegEncContext * s, int pred);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
56 static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
986e461dc072 Initial revision
glantau
parents:
diff changeset
57 int n, int coded);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
58 static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
59 static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
60 int n, int coded, int intra);
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
61 static int h263_pred_dc(MpegEncContext * s, int n, UINT16 **dc_val_ptr);
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
62 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
63 int dir);
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
64 static void mpeg4_decode_sprite_trajectory(MpegEncContext * s);
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
65
277
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
66 extern UINT32 inverse[256];
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
67
292
73a9ce3d9715 fcode_tables where too small, found by Klaas-Pieter Vlieg <vlieg@eurescom.de>
michaelni
parents: 291
diff changeset
68 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
69 static UINT8 fcode_tab[MAX_MV*2+1];
287
32a3dcce2e9b fixing motion estimation with h263p hopefully
michaelni
parents: 286
diff changeset
70 static UINT8 umv_fcode_tab[MAX_MV*2+1];
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
71
293
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
72 static UINT16 uni_DCtab_lum [512][2];
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
73 static UINT16 uni_DCtab_chrom[512][2];
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
74
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
75 int h263_get_picture_format(int width, int height)
986e461dc072 Initial revision
glantau
parents:
diff changeset
76 {
986e461dc072 Initial revision
glantau
parents:
diff changeset
77 int format;
986e461dc072 Initial revision
glantau
parents:
diff changeset
78
986e461dc072 Initial revision
glantau
parents:
diff changeset
79 if (width == 128 && height == 96)
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
80 format = 1;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
81 else if (width == 176 && height == 144)
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
82 format = 2;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
83 else if (width == 352 && height == 288)
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
84 format = 3;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
85 else if (width == 704 && height == 576)
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
86 format = 4;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
87 else if (width == 1408 && height == 1152)
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
88 format = 5;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
89 else
986e461dc072 Initial revision
glantau
parents:
diff changeset
90 format = 7;
986e461dc072 Initial revision
glantau
parents:
diff changeset
91 return format;
986e461dc072 Initial revision
glantau
parents:
diff changeset
92 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
93
986e461dc072 Initial revision
glantau
parents:
diff changeset
94 void h263_encode_picture_header(MpegEncContext * s, int picture_number)
986e461dc072 Initial revision
glantau
parents:
diff changeset
95 {
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
96 int format;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
97
986e461dc072 Initial revision
glantau
parents:
diff changeset
98 align_put_bits(&s->pb);
231
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
99
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
100 /* 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
101 s->ptr_lastgob = pbBufPtr(&s->pb);
231
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
102 s->gob_number = 0;
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
103
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
104 put_bits(&s->pb, 22, 0x20); /* PSC */
241
4bb6289eff93 avoid overflow of picturenumber*fps*10000
michaelni
parents: 234
diff changeset
105 put_bits(&s->pb, 8, (((INT64)s->picture_number * 30 * FRAME_RATE_BASE) /
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
106 s->frame_rate) & 0xff);
986e461dc072 Initial revision
glantau
parents:
diff changeset
107
986e461dc072 Initial revision
glantau
parents:
diff changeset
108 put_bits(&s->pb, 1, 1); /* marker */
986e461dc072 Initial revision
glantau
parents:
diff changeset
109 put_bits(&s->pb, 1, 0); /* h263 id */
986e461dc072 Initial revision
glantau
parents:
diff changeset
110 put_bits(&s->pb, 1, 0); /* split screen off */
986e461dc072 Initial revision
glantau
parents:
diff changeset
111 put_bits(&s->pb, 1, 0); /* camera off */
986e461dc072 Initial revision
glantau
parents:
diff changeset
112 put_bits(&s->pb, 1, 0); /* freeze picture release off */
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
113
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
114 format = h263_get_picture_format(s->width, s->height);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
115 if (!s->h263_plus) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
116 /* H.263v1 */
986e461dc072 Initial revision
glantau
parents:
diff changeset
117 put_bits(&s->pb, 3, format);
986e461dc072 Initial revision
glantau
parents:
diff changeset
118 put_bits(&s->pb, 1, (s->pict_type == P_TYPE));
986e461dc072 Initial revision
glantau
parents:
diff changeset
119 /* By now UMV IS DISABLED ON H.263v1, since the restrictions
986e461dc072 Initial revision
glantau
parents:
diff changeset
120 of H.263v1 UMV implies to check the predicted MV after
986e461dc072 Initial revision
glantau
parents:
diff changeset
121 calculation of the current MB to see if we're on the limits */
986e461dc072 Initial revision
glantau
parents:
diff changeset
122 put_bits(&s->pb, 1, 0); /* unrestricted motion vector: off */
986e461dc072 Initial revision
glantau
parents:
diff changeset
123 put_bits(&s->pb, 1, 0); /* SAC: off */
986e461dc072 Initial revision
glantau
parents:
diff changeset
124 put_bits(&s->pb, 1, 0); /* advanced prediction mode: off */
986e461dc072 Initial revision
glantau
parents:
diff changeset
125 put_bits(&s->pb, 1, 0); /* not PB frame */
986e461dc072 Initial revision
glantau
parents:
diff changeset
126 put_bits(&s->pb, 5, s->qscale);
986e461dc072 Initial revision
glantau
parents:
diff changeset
127 put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */
986e461dc072 Initial revision
glantau
parents:
diff changeset
128 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
129 /* H.263v2 */
986e461dc072 Initial revision
glantau
parents:
diff changeset
130 /* H.263 Plus PTYPE */
986e461dc072 Initial revision
glantau
parents:
diff changeset
131 put_bits(&s->pb, 3, 7);
986e461dc072 Initial revision
glantau
parents:
diff changeset
132 put_bits(&s->pb,3,1); /* Update Full Extended PTYPE */
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
133 if (format == 7)
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
134 put_bits(&s->pb,3,6); /* Custom Source Format */
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
135 else
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
136 put_bits(&s->pb, 3, format);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
137
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
138 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
139 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
140 put_bits(&s->pb, 1, s->umvplus); /* Unrestricted Motion Vector */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
141 put_bits(&s->pb,1,0); /* SAC: off */
986e461dc072 Initial revision
glantau
parents:
diff changeset
142 put_bits(&s->pb,1,0); /* Advanced Prediction Mode: off */
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
143 put_bits(&s->pb,1,s->h263_aic); /* Advanced Intra Coding */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
144 put_bits(&s->pb,1,0); /* Deblocking Filter: off */
986e461dc072 Initial revision
glantau
parents:
diff changeset
145 put_bits(&s->pb,1,0); /* Slice Structured: off */
986e461dc072 Initial revision
glantau
parents:
diff changeset
146 put_bits(&s->pb,1,0); /* Reference Picture Selection: off */
986e461dc072 Initial revision
glantau
parents:
diff changeset
147 put_bits(&s->pb,1,0); /* Independent Segment Decoding: off */
986e461dc072 Initial revision
glantau
parents:
diff changeset
148 put_bits(&s->pb,1,0); /* Alternative Inter VLC: off */
986e461dc072 Initial revision
glantau
parents:
diff changeset
149 put_bits(&s->pb,1,0); /* Modified Quantization: off */
986e461dc072 Initial revision
glantau
parents:
diff changeset
150 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
986e461dc072 Initial revision
glantau
parents:
diff changeset
151 put_bits(&s->pb,3,0); /* Reserved */
986e461dc072 Initial revision
glantau
parents:
diff changeset
152
986e461dc072 Initial revision
glantau
parents:
diff changeset
153 put_bits(&s->pb, 3, s->pict_type == P_TYPE);
986e461dc072 Initial revision
glantau
parents:
diff changeset
154
986e461dc072 Initial revision
glantau
parents:
diff changeset
155 put_bits(&s->pb,1,0); /* Reference Picture Resampling: off */
986e461dc072 Initial revision
glantau
parents:
diff changeset
156 put_bits(&s->pb,1,0); /* Reduced-Resolution Update: off */
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
157 if (s->pict_type == I_TYPE)
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
158 s->no_rounding = 0;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
159 else
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
160 s->no_rounding ^= 1;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
161 put_bits(&s->pb,1,s->no_rounding); /* Rounding Type */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
162 put_bits(&s->pb,2,0); /* Reserved */
986e461dc072 Initial revision
glantau
parents:
diff changeset
163 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
986e461dc072 Initial revision
glantau
parents:
diff changeset
164
986e461dc072 Initial revision
glantau
parents:
diff changeset
165 /* This should be here if PLUSPTYPE */
986e461dc072 Initial revision
glantau
parents:
diff changeset
166 put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */
986e461dc072 Initial revision
glantau
parents:
diff changeset
167
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
168 if (format == 7) {
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
169 /* Custom Picture Format (CPFMT) */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
170
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
171 if (s->aspect_ratio_info)
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
172 put_bits(&s->pb,4,s->aspect_ratio_info);
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
173 else
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
174 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
175 put_bits(&s->pb,9,(s->width >> 2) - 1);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
176 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
177 put_bits(&s->pb,9,(s->height >> 2));
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
178 }
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
179
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
180 /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
79
82e579c37bc3 Moved some H.263+ variables to MpegEncContext to be thread-safe.
pulento
parents: 78
diff changeset
181 if (s->umvplus)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
182 put_bits(&s->pb,1,1); /* Limited according tables of Annex D */
986e461dc072 Initial revision
glantau
parents:
diff changeset
183 put_bits(&s->pb, 5, s->qscale);
986e461dc072 Initial revision
glantau
parents:
diff changeset
184 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
185
986e461dc072 Initial revision
glantau
parents:
diff changeset
186 put_bits(&s->pb, 1, 0); /* no PEI */
498
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
187
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
188 if(s->h263_aic){
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
189 s->y_dc_scale_table=
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
190 s->c_dc_scale_table= h263_aic_dc_scale_table;
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
191 }else{
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
192 s->y_dc_scale_table=
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
193 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
194 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
195 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
196
162
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
197 int h263_encode_gob_header(MpegEncContext * s, int mb_line)
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
198 {
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
199 int pdif=0;
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
200
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
201 /* Check to see if we need to put a new GBSC */
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
202 /* for RTP packetization */
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
203 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
204 pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;
162
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
205 if (pdif >= s->rtp_payload_size) {
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
206 /* Bad luck, packet must be cut before */
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
207 align_put_bits(&s->pb);
231
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
208 flush_put_bits(&s->pb);
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
209 /* Call the RTP callback to send the last GOB */
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
210 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
211 pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;
231
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
212 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
213 }
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
214 s->ptr_lastgob = pbBufPtr(&s->pb);
162
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
215 put_bits(&s->pb, 17, 1); /* GBSC */
231
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
216 s->gob_number = mb_line / s->gob_index;
162
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
217 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
218 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
219 put_bits(&s->pb, 5, s->qscale); /* GQUANT */
231
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
220 //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
221 return pdif;
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
222 } else if (pdif + s->mb_line_avgsize >= s->rtp_payload_size) {
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
223 /* Cut the packet before we can't */
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
224 align_put_bits(&s->pb);
231
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
225 flush_put_bits(&s->pb);
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
226 /* Call the RTP callback to send the last GOB */
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
227 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
228 pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;
231
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
229 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
230 }
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
231 s->ptr_lastgob = pbBufPtr(&s->pb);
162
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
232 put_bits(&s->pb, 17, 1); /* GBSC */
231
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
233 s->gob_number = mb_line / s->gob_index;
162
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
234 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
235 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
236 put_bits(&s->pb, 5, s->qscale); /* GQUANT */
231
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
237 //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
238 return pdif;
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
239 }
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
240 }
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
241 return 0;
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
242 }
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
243
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
244 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
245 {
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
246 int score0=0, score1=0;
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
247 int i, n;
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
248
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
249 for(n=0; n<6; n++){
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
250 INT16 *ac_val, *ac_val1;
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
251
266
252444e5259b optimization
michaelni
parents: 265
diff changeset
252 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
253 ac_val1= ac_val;
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
254 if(dir[n]){
266
252444e5259b optimization
michaelni
parents: 265
diff changeset
255 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
256 for(i=1; i<8; i++){
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
257 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
258 score0+= ABS(level);
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
259 score1+= ABS(level - ac_val[i+8]);
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
260 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
261 ac_val1[i+8]= level;
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
262 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
263 }else{
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
264 ac_val-= 16;
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
265 for(i=1; i<8; i++){
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
266 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
267 score0+= ABS(level);
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
268 score1+= ABS(level - ac_val[i]);
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
269 ac_val1[i ]= level;
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
270 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
271 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
272 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
273 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
274
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
275 return score0 > score1 ? 1 : 0;
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
276 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
277
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
278 void mpeg4_encode_mb(MpegEncContext * s,
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
279 DCTELEM block[6][64],
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
280 int motion_x, int motion_y)
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
281 {
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
282 int cbpc, cbpy, i, pred_x, pred_y;
286
91f7c38f5f37 statistics for 2-pass encoding
michaelni
parents: 285
diff changeset
283 int bits;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
284 PutBitContext * const pb2 = s->data_partitioning ? &s->pb2 : &s->pb;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
285 PutBitContext * const tex_pb = s->data_partitioning && s->pict_type!=B_TYPE ? &s->tex_pb : &s->pb;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
286 PutBitContext * const dc_pb = s->data_partitioning && s->pict_type!=I_TYPE ? &s->pb2 : &s->pb;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
287 const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1) && !s->data_partitioning ? 1 : 0;
162
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
288
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
289 // 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
290 if (!s->mb_intra) {
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
291 /* compute cbp */
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
292 int cbp = 0;
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
293 for (i = 0; i < 6; i++) {
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
294 if (s->block_last_index[i] >= 0)
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
295 cbp |= 1 << (5 - i);
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
296 }
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
297
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
298 if(s->pict_type==B_TYPE){
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
299 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
300 int mb_type= mb_type_table[s->mv_dir];
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(s->mb_x==0){
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
303 s->last_mv[0][0][0]=
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
304 s->last_mv[0][0][1]=
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
305 s->last_mv[1][0][0]=
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
306 s->last_mv[1][0][1]= 0;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
307 }
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
308
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
309 /* 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
310 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
311 s->skip_count++;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
312 s->mv[0][0][0]=
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
313 s->mv[0][0][1]=
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
314 s->mv[1][0][0]=
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
315 s->mv[1][0][1]= 0;
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
316 s->mv_dir= MV_DIR_FORWARD; //doesnt matter
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
317 return;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
318 }
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
319
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
320 if ((cbp | motion_x | motion_y | mb_type) ==0) {
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
321 /* direct MB with MV={0,0} */
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
322 put_bits(&s->pb, 1, 1); /* mb not coded modb1=1 */
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
323
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
324 if(interleaved_stats){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
325 s->misc_bits++;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
326 s->last_bits++;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
327 }
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
328 s->skip_count++;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
329 return;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
330 }
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
331 put_bits(&s->pb, 1, 0); /* mb coded modb1=0 */
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
332 put_bits(&s->pb, 1, cbp ? 0 : 1); /* modb2 */ //FIXME merge
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
333 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
334 if(cbp) put_bits(&s->pb, 6, cbp);
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
335
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
336 if(cbp && mb_type)
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
337 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
338
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
339 if(interleaved_stats){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
340 bits= get_bit_count(&s->pb);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
341 s->misc_bits+= bits - s->last_bits;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
342 s->last_bits=bits;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
343 }
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 switch(mb_type)
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
346 {
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
347 case 0: /* direct */
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
348 h263_encode_motion(s, motion_x, 1);
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
349 h263_encode_motion(s, motion_y, 1);
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
350 break;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
351 case 1: /* bidir */
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
352 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
353 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
354 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
355 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
356 s->last_mv[0][0][0]= s->mv[0][0][0];
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
357 s->last_mv[0][0][1]= s->mv[0][0][1];
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
358 s->last_mv[1][0][0]= s->mv[1][0][0];
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
359 s->last_mv[1][0][1]= s->mv[1][0][1];
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
360 break;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
361 case 2: /* backward */
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
362 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
363 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
364 s->last_mv[1][0][0]= motion_x;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
365 s->last_mv[1][0][1]= motion_y;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
366 break;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
367 case 3: /* forward */
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
368 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
369 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
370 s->last_mv[0][0][0]= motion_x;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
371 s->last_mv[0][0][1]= motion_y;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
372 break;
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
373 default:
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
374 printf("unknown mb type\n");
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
375 return;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
376 }
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
377
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
378 if(interleaved_stats){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
379 bits= get_bit_count(&s->pb);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
380 s->mv_bits+= bits - s->last_bits;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
381 s->last_bits=bits;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
382 }
295
6622b0fd036c mpeg4 4MV encoding
michaelni
parents: 294
diff changeset
383
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
384 /* encode each block */
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
385 for (i = 0; i < 6; i++) {
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
386 mpeg4_encode_block(s, block[i], i, 0, zigzag_direct, NULL, &s->pb);
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
387 }
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
388
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
389 if(interleaved_stats){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
390 bits= get_bit_count(&s->pb);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
391 s->p_tex_bits+= bits - s->last_bits;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
392 s->last_bits=bits;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
393 }
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
394 }else{ /* s->pict_type==B_TYPE */
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
395 if ((cbp | motion_x | motion_y) == 0 && s->mv_type==MV_TYPE_16X16) {
331
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
396 /* check if the B frames can skip it too, as we must skip it if we skip here
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
397 why didnt they just compress the skip-mb bits instead of reusing them ?! */
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
398 if(s->max_b_frames>0){
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
399 int i;
364
6b6332e7008a segfault fix for b-frame encoding with height%16!=0
michaelni
parents: 360
diff changeset
400 int x,y, offset;
6b6332e7008a segfault fix for b-frame encoding with height%16!=0
michaelni
parents: 360
diff changeset
401 uint8_t *p_pic;
6b6332e7008a segfault fix for b-frame encoding with height%16!=0
michaelni
parents: 360
diff changeset
402
6b6332e7008a segfault fix for b-frame encoding with height%16!=0
michaelni
parents: 360
diff changeset
403 x= s->mb_x*16;
6b6332e7008a segfault fix for b-frame encoding with height%16!=0
michaelni
parents: 360
diff changeset
404 y= s->mb_y*16;
6b6332e7008a segfault fix for b-frame encoding with height%16!=0
michaelni
parents: 360
diff changeset
405 if(x+16 > s->width) x= s->width-16;
6b6332e7008a segfault fix for b-frame encoding with height%16!=0
michaelni
parents: 360
diff changeset
406 if(y+16 > s->height) y= s->height-16;
6b6332e7008a segfault fix for b-frame encoding with height%16!=0
michaelni
parents: 360
diff changeset
407
6b6332e7008a segfault fix for b-frame encoding with height%16!=0
michaelni
parents: 360
diff changeset
408 offset= x + y*s->linesize;
6b6332e7008a segfault fix for b-frame encoding with height%16!=0
michaelni
parents: 360
diff changeset
409 p_pic= s->new_picture[0] + offset;
6b6332e7008a segfault fix for b-frame encoding with height%16!=0
michaelni
parents: 360
diff changeset
410
331
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
411 s->mb_skiped=1;
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
412 for(i=0; i<s->max_b_frames; i++){
339
b743a6bbab25 segfault fix
michaelni
parents: 336
diff changeset
413 uint8_t *b_pic;
b743a6bbab25 segfault fix
michaelni
parents: 336
diff changeset
414 int diff;
b743a6bbab25 segfault fix
michaelni
parents: 336
diff changeset
415
b743a6bbab25 segfault fix
michaelni
parents: 336
diff changeset
416 if(s->coded_order[i+1].pict_type!=B_TYPE) break;
b743a6bbab25 segfault fix
michaelni
parents: 336
diff changeset
417
b743a6bbab25 segfault fix
michaelni
parents: 336
diff changeset
418 b_pic= s->coded_order[i+1].picture[0] + offset;
b743a6bbab25 segfault fix
michaelni
parents: 336
diff changeset
419 diff= pix_abs16x16(p_pic, b_pic, s->linesize);
364
6b6332e7008a segfault fix for b-frame encoding with height%16!=0
michaelni
parents: 360
diff changeset
420 if(diff>s->qscale*70){ //FIXME check that 70 is optimal
331
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
421 s->mb_skiped=0;
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
422 break;
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
423 }
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
424 }
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
425 }else
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
426 s->mb_skiped=1;
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
427
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
428 if(s->mb_skiped==1){
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
429 /* skip macroblock */
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
430 put_bits(&s->pb, 1, 1);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
431
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
432 if(interleaved_stats){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
433 s->misc_bits++;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
434 s->last_bits++;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
435 }
331
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
436 s->skip_count++;
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
437 return;
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
438 }
295
6622b0fd036c mpeg4 4MV encoding
michaelni
parents: 294
diff changeset
439 }
364
6b6332e7008a segfault fix for b-frame encoding with height%16!=0
michaelni
parents: 360
diff changeset
440
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
441 put_bits(&s->pb, 1, 0); /* mb coded */
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
442 if(s->mv_type==MV_TYPE_16X16){
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
443 cbpc = cbp & 3;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
444 put_bits(&s->pb,
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
445 inter_MCBPC_bits[cbpc],
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
446 inter_MCBPC_code[cbpc]);
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
447 cbpy = cbp >> 2;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
448 cbpy ^= 0xf;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
449 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
450
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
451 if(interleaved_stats){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
452 bits= get_bit_count(&s->pb);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
453 s->misc_bits+= bits - s->last_bits;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
454 s->last_bits=bits;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
455 }
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
456
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
457 /* motion vectors: 16x16 mode */
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
458 h263_pred_motion(s, 0, &pred_x, &pred_y);
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
459
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
460 h263_encode_motion(s, motion_x - pred_x, s->f_code);
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
461 h263_encode_motion(s, motion_y - pred_y, s->f_code);
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
462 }else{
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
463 cbpc = (cbp & 3)+16;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
464 put_bits(&s->pb,
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
465 inter_MCBPC_bits[cbpc],
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
466 inter_MCBPC_code[cbpc]);
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
467 cbpy = cbp >> 2;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
468 cbpy ^= 0xf;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
469 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
470
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
471 if(interleaved_stats){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
472 bits= get_bit_count(&s->pb);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
473 s->misc_bits+= bits - s->last_bits;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
474 s->last_bits=bits;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
475 }
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
476
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
477 for(i=0; i<4; i++){
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
478 /* motion vectors: 8x8 mode*/
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
479 h263_pred_motion(s, i, &pred_x, &pred_y);
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
480
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
481 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
482 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
483 }
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
484 }
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
485
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
486 if(interleaved_stats){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
487 bits= get_bit_count(&s->pb);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
488 s->mv_bits+= bits - s->last_bits;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
489 s->last_bits=bits;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
490 }
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
491
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
492 /* encode each block */
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
493 for (i = 0; i < 6; i++) {
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
494 mpeg4_encode_block(s, block[i], i, 0, zigzag_direct, NULL, tex_pb);
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
495 }
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
496
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
497 if(interleaved_stats){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
498 bits= get_bit_count(&s->pb);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
499 s->p_tex_bits+= bits - s->last_bits;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
500 s->last_bits=bits;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
501 }
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
502 s->p_count++;
295
6622b0fd036c mpeg4 4MV encoding
michaelni
parents: 294
diff changeset
503 }
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
504 } else {
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
505 int cbp;
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
506 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
507 int dir[6]; //prediction direction
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
508 int zigzag_last_index[6];
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
509 UINT8 *scan_table[6];
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 for(i=0; i<6; i++){
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
512 const int level= block[i][0];
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
513 UINT16 *dc_ptr;
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
514
498
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
515 dc_diff[i]= level - ff_mpeg4_pred_dc(s, i, &dc_ptr, &dir[i]);
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
516 if (i < 4) {
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
517 *dc_ptr = level * s->y_dc_scale;
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
518 } else {
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
519 *dc_ptr = level * s->c_dc_scale;
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
520 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
521 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
522
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
523 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
524
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
525 if(s->ac_pred){
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
526 for(i=0; i<6; i++){
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
527 UINT8 *st;
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
528 int last_index;
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
529
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
530 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
531 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
532 else st = ff_alternate_horizontal_scan; /* top */
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
533
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
534 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
535 if(block[i][st[last_index]]) break;
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
536 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
537 s->block_last_index[i]= last_index;
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
538 scan_table[i]= st;
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
539 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
540 }else{
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
541 for(i=0; i<6; i++)
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
542 scan_table[i]= zigzag_direct;
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
543 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
544
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
545 /* compute cbp */
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
546 cbp = 0;
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
547 for (i = 0; i < 6; i++) {
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
548 if (s->block_last_index[i] >= 1)
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
549 cbp |= 1 << (5 - i);
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
550 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
551
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
552 cbpc = cbp & 3;
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
553 if (s->pict_type == I_TYPE) {
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
554 put_bits(&s->pb,
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
555 intra_MCBPC_bits[cbpc],
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
556 intra_MCBPC_code[cbpc]);
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
557 } else {
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
558 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
559 put_bits(&s->pb,
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
560 inter_MCBPC_bits[cbpc + 4],
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
561 inter_MCBPC_code[cbpc + 4]);
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
562 }
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
563 put_bits(pb2, 1, s->ac_pred);
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
564 cbpy = cbp >> 2;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
565 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
566
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
567 if(interleaved_stats){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
568 bits= get_bit_count(&s->pb);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
569 s->misc_bits+= bits - s->last_bits;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
570 s->last_bits=bits;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
571 }
286
91f7c38f5f37 statistics for 2-pass encoding
michaelni
parents: 285
diff changeset
572
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
573 /* encode each block */
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
574 for (i = 0; i < 6; i++) {
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
575 mpeg4_encode_block(s, block[i], i, dc_diff[i], scan_table[i], dc_pb, tex_pb);
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
576 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
577
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
578 if(interleaved_stats){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
579 bits= get_bit_count(&s->pb);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
580 s->i_tex_bits+= bits - s->last_bits;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
581 s->last_bits=bits;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
582 }
286
91f7c38f5f37 statistics for 2-pass encoding
michaelni
parents: 285
diff changeset
583 s->i_count++;
91f7c38f5f37 statistics for 2-pass encoding
michaelni
parents: 285
diff changeset
584
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
585 /* 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
586 if(s->ac_pred){
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
587 for(i=0; i<6; i++){
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
588 int j;
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
589 INT16 *ac_val;
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
590
266
252444e5259b optimization
michaelni
parents: 265
diff changeset
591 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
592
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
593 if(dir[i]){
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
594 for(j=1; j<8; j++)
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
595 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
596 }else{
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
597 for(j=1; j<8; j++)
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
598 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
599 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
600 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
601 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
602 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
603 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
604 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
605
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
606 void h263_encode_mb(MpegEncContext * s,
986e461dc072 Initial revision
glantau
parents:
diff changeset
607 DCTELEM block[6][64],
986e461dc072 Initial revision
glantau
parents:
diff changeset
608 int motion_x, int motion_y)
986e461dc072 Initial revision
glantau
parents:
diff changeset
609 {
986e461dc072 Initial revision
glantau
parents:
diff changeset
610 int cbpc, cbpy, i, cbp, pred_x, pred_y;
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
611 INT16 pred_dc;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
612 INT16 rec_intradc[6];
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
613 UINT16 *dc_ptr[6];
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
614
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
615 //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
616 if (!s->mb_intra) {
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
617 /* compute cbp */
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
618 cbp = 0;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
619 for (i = 0; i < 6; i++) {
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
620 if (s->block_last_index[i] >= 0)
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
621 cbp |= 1 << (5 - i);
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
622 }
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
623 if ((cbp | motion_x | motion_y) == 0) {
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
624 /* skip macroblock */
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
625 put_bits(&s->pb, 1, 1);
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
626 return;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
627 }
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
628 put_bits(&s->pb, 1, 0); /* mb coded */
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
629 cbpc = cbp & 3;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
630 put_bits(&s->pb,
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
631 inter_MCBPC_bits[cbpc],
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
632 inter_MCBPC_code[cbpc]);
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
633 cbpy = cbp >> 2;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
634 cbpy ^= 0xf;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
635 put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
636
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
637 /* motion vectors: 16x16 mode only now */
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
638 h263_pred_motion(s, 0, &pred_x, &pred_y);
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
639
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
640 if (!s->umvplus) {
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
641 h263_encode_motion(s, motion_x - pred_x, s->f_code);
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
642 h263_encode_motion(s, motion_y - pred_y, s->f_code);
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
643 }
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
644 else {
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
645 h263p_encode_umotion(s, motion_x - pred_x);
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
646 h263p_encode_umotion(s, motion_y - pred_y);
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
647 if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
648 /* To prevent Start Code emulation */
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
649 put_bits(&s->pb,1,1);
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
650 }
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
651 } else {
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
652 int li = s->h263_aic ? 0 : 1;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
653
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
654 cbp = 0;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
655 for(i=0; i<6; i++) {
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
656 /* Predict DC */
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
657 if (s->h263_aic && s->mb_intra) {
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
658 INT16 level = block[i][0];
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
659
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
660 pred_dc = h263_pred_dc(s, i, &dc_ptr[i]);
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
661 level -= pred_dc;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
662 /* Quant */
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
663 if (level < 0)
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
664 level = (level + (s->qscale >> 1))/(s->y_dc_scale);
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
665 else
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
666 level = (level - (s->qscale >> 1))/(s->y_dc_scale);
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
667
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
668 /* AIC can change CBP */
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
669 if (level == 0 && s->block_last_index[i] == 0)
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
670 s->block_last_index[i] = -1;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
671 else if (level < -127)
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
672 level = -127;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
673 else if (level > 127)
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
674 level = 127;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
675
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
676 block[i][0] = level;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
677 /* Reconstruction */
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
678 rec_intradc[i] = (s->y_dc_scale*level) + pred_dc;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
679 /* Oddify */
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
680 rec_intradc[i] |= 1;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
681 //if ((rec_intradc[i] % 2) == 0)
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
682 // rec_intradc[i]++;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
683 /* Clipping */
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
684 if (rec_intradc[i] < 0)
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
685 rec_intradc[i] = 0;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
686 else if (rec_intradc[i] > 2047)
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
687 rec_intradc[i] = 2047;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
688
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
689 /* Update AC/DC tables */
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
690 *dc_ptr[i] = rec_intradc[i];
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
691 }
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
692 /* compute cbp */
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
693 if (s->block_last_index[i] >= li)
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
694 cbp |= 1 << (5 - i);
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
695 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
696
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
697 cbpc = cbp & 3;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
698 if (s->pict_type == I_TYPE) {
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
699 put_bits(&s->pb,
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
700 intra_MCBPC_bits[cbpc],
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
701 intra_MCBPC_code[cbpc]);
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
702 } else {
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
703 put_bits(&s->pb, 1, 0); /* mb coded */
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
704 put_bits(&s->pb,
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
705 inter_MCBPC_bits[cbpc + 4],
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
706 inter_MCBPC_code[cbpc + 4]);
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
707 }
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
708 if (s->h263_aic) {
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
709 /* XXX: currently, we do not try to use ac prediction */
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
710 put_bits(&s->pb, 1, 0); /* no AC prediction */
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
711 }
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
712 cbpy = cbp >> 2;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
713 put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
714 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
715
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
716 for(i=0; i<6; i++) {
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
717 /* encode each block */
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 293
diff changeset
718 h263_encode_block(s, block[i], i);
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
719
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
720 /* Update INTRADC for decoding */
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
721 if (s->h263_aic && s->mb_intra) {
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
722 block[i][0] = rec_intradc[i];
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
723
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
724 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
725 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
726 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
727
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
728 static int h263_pred_dc(MpegEncContext * s, int n, UINT16 **dc_val_ptr)
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
729 {
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
730 int x, y, wrap, a, c, pred_dc, scale;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
731 INT16 *dc_val, *ac_val;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
732
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
733 /* find prediction */
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
734 if (n < 4) {
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
735 x = 2 * s->mb_x + 1 + (n & 1);
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
736 y = 2 * s->mb_y + 1 + ((n & 2) >> 1);
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
737 wrap = s->mb_width * 2 + 2;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
738 dc_val = s->dc_val[0];
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
739 ac_val = s->ac_val[0][0];
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
740 scale = s->y_dc_scale;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
741 } else {
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
742 x = s->mb_x + 1;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
743 y = s->mb_y + 1;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
744 wrap = s->mb_width + 2;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
745 dc_val = s->dc_val[n - 4 + 1];
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
746 ac_val = s->ac_val[n - 4 + 1][0];
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
747 scale = s->c_dc_scale;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
748 }
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
749 /* B C
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
750 * A X
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
751 */
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
752 a = dc_val[(x - 1) + (y) * wrap];
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
753 c = dc_val[(x) + (y - 1) * wrap];
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
754
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
755 /* No prediction outside GOB boundary */
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
756 if (s->first_slice_line && ((n < 2) || (n > 3)))
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
757 c = 1024;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
758 pred_dc = 1024;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
759 /* just DC prediction */
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
760 if (a != 1024 && c != 1024)
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
761 pred_dc = (a + c) >> 1;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
762 else if (a != 1024)
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
763 pred_dc = a;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
764 else
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
765 pred_dc = c;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
766
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
767 /* we assume pred is positive */
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
768 //pred_dc = (pred_dc + (scale >> 1)) / scale;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
769 *dc_val_ptr = &dc_val[x + y * wrap];
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
770 return pred_dc;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
771 }
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
772
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
773
249
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
774 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
775 {
249
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
776 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
777 INT16 *dc_val, *ac_val, *ac_val1;
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
778
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
779 /* find prediction */
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
780 if (n < 4) {
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
781 x = 2 * s->mb_x + 1 + (n & 1);
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
782 y = 2 * s->mb_y + 1 + ((n & 2) >> 1);
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
783 wrap = s->mb_width * 2 + 2;
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
784 dc_val = s->dc_val[0];
249
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
785 ac_val = s->ac_val[0][0];
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
786 scale = s->y_dc_scale;
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
787 } else {
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
788 x = s->mb_x + 1;
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
789 y = s->mb_y + 1;
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
790 wrap = s->mb_width + 2;
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
791 dc_val = s->dc_val[n - 4 + 1];
249
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
792 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
793 scale = s->c_dc_scale;
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
794 }
249
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
795
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
796 ac_val += ((y) * wrap + (x)) * 16;
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
797 ac_val1 = ac_val;
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
798
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
799 /* B C
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
800 * A X
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
801 */
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
802 a = dc_val[(x - 1) + (y) * wrap];
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
803 c = dc_val[(x) + (y - 1) * wrap];
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
804
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
805 /* No prediction outside GOB boundary */
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
806 if (s->first_slice_line && ((n < 2) || (n > 3)))
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
807 c = 1024;
249
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
808 pred_dc = 1024;
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
809 if (s->ac_pred) {
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
810 if (s->h263_aic_dir) {
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
811 /* left prediction */
249
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
812 if (a != 1024) {
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
813 ac_val -= 16;
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
814 for(i=1;i<8;i++) {
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
815 block[block_permute_op(i*8)] += ac_val[i];
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
816 }
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
817 pred_dc = a;
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
818 }
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
819 } else {
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
820 /* top prediction */
249
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
821 if (c != 1024) {
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
822 ac_val -= 16 * wrap;
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
823 for(i=1;i<8;i++) {
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
824 block[block_permute_op(i)] += ac_val[i + 8];
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
825 }
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
826 pred_dc = c;
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
827 }
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
828 }
249
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
829 } else {
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
830 /* just DC prediction */
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
831 if (a != 1024 && c != 1024)
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
832 pred_dc = (a + c) >> 1;
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
833 else if (a != 1024)
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
834 pred_dc = a;
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
835 else
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
836 pred_dc = c;
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
837 }
249
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
838
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
839 /* we assume pred is positive */
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
840 block[0]=block[0]*scale + pred_dc;
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
841
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
842 if (block[0] < 0)
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
843 block[0] = 0;
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
844 else if (!(block[0] & 1))
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
845 block[0]++;
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
846
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
847 /* Update AC/DC tables */
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
848 dc_val[(x) + (y) * wrap] = block[0];
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
849
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
850 /* left copy */
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
851 for(i=1;i<8;i++)
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
852 ac_val1[i] = block[block_permute_op(i * 8)];
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
853 /* top copy */
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
854 for(i=1;i<8;i++)
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
855 ac_val1[8 + i] = block[block_permute_op(i)];
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
856 }
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
857
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
858 INT16 *h263_pred_motion(MpegEncContext * s, int block,
986e461dc072 Initial revision
glantau
parents:
diff changeset
859 int *px, int *py)
986e461dc072 Initial revision
glantau
parents:
diff changeset
860 {
266
252444e5259b optimization
michaelni
parents: 265
diff changeset
861 int xy, wrap;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
862 INT16 *A, *B, *C, *mot_val;
264
28c5c62b1c4c support decoding (with mplayer) of 3 .mp4 files from mphq
michaelni
parents: 263
diff changeset
863 static const int off[4]= {2, 1, 1, -1};
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
864
266
252444e5259b optimization
michaelni
parents: 265
diff changeset
865 wrap = s->block_wrap[0];
252444e5259b optimization
michaelni
parents: 265
diff changeset
866 xy = s->block_index[block];
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
867
245
a023f78e0cc2 * simplified indexing
kabi
parents: 241
diff changeset
868 mot_val = s->motion_val[xy];
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
869
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
870 A = s->motion_val[xy - 1];
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
871 /* special case for first (slice) line */
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
872 if ((s->mb_y == 0 || s->first_slice_line) && block<3) {
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
873 // we cant just change some MVs to simulate that as we need them for the B frames (and ME)
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
874 // and if we ever support non rectangular objects than we need to do a few ifs here anyway :(
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
875 if(block==0){ //most common case
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
876 if(s->mb_x == s->resync_mb_x){ //rare
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
877 *px= *py = 0;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
878 }else if(s->mb_x + 1 == s->resync_mb_x){ //rare
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
879 C = s->motion_val[xy + off[block] - wrap];
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
880 if(s->mb_x==0){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
881 *px = C[0];
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
882 *py = C[1];
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
883 }else{
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
884 *px = mid_pred(A[0], 0, C[0]);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
885 *py = mid_pred(A[1], 0, C[1]);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
886 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
887 }else{
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
888 *px = A[0];
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
889 *py = A[1];
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
890 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
891 }else if(block==1){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
892 if(s->mb_x + 1 == s->resync_mb_x){ //rare
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
893 C = s->motion_val[xy + off[block] - wrap];
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
894 *px = mid_pred(A[0], 0, C[0]);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
895 *py = mid_pred(A[1], 0, C[1]);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
896 }else{
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
897 *px = A[0];
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
898 *py = A[1];
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
899 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
900 }else{ /* block==2*/
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
901 B = s->motion_val[xy - wrap];
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
902 C = s->motion_val[xy + off[block] - wrap];
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
903 if(s->mb_x == s->resync_mb_x) //rare
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
904 A[0]=A[1]=0;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
905
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
906 *px = mid_pred(A[0], B[0], C[0]);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
907 *py = mid_pred(A[1], B[1], C[1]);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
908 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
909 } else {
264
28c5c62b1c4c support decoding (with mplayer) of 3 .mp4 files from mphq
michaelni
parents: 263
diff changeset
910 B = s->motion_val[xy - wrap];
28c5c62b1c4c support decoding (with mplayer) of 3 .mp4 files from mphq
michaelni
parents: 263
diff changeset
911 C = s->motion_val[xy + off[block] - wrap];
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
912 *px = mid_pred(A[0], B[0], C[0]);
986e461dc072 Initial revision
glantau
parents:
diff changeset
913 *py = mid_pred(A[1], B[1], C[1]);
986e461dc072 Initial revision
glantau
parents:
diff changeset
914 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
915 return mot_val;
986e461dc072 Initial revision
glantau
parents:
diff changeset
916 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
917
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
918 static void h263_encode_motion(MpegEncContext * s, int val, int f_code)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
919 {
986e461dc072 Initial revision
glantau
parents:
diff changeset
920 int range, l, m, bit_size, sign, code, bits;
986e461dc072 Initial revision
glantau
parents:
diff changeset
921
986e461dc072 Initial revision
glantau
parents:
diff changeset
922 if (val == 0) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
923 /* zero vector */
986e461dc072 Initial revision
glantau
parents:
diff changeset
924 code = 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
925 put_bits(&s->pb, mvtab[code][1], mvtab[code][0]);
986e461dc072 Initial revision
glantau
parents:
diff changeset
926 } else {
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
927 bit_size = f_code - 1;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
928 range = 1 << bit_size;
986e461dc072 Initial revision
glantau
parents:
diff changeset
929 /* modulo encoding */
986e461dc072 Initial revision
glantau
parents:
diff changeset
930 l = range * 32;
986e461dc072 Initial revision
glantau
parents:
diff changeset
931 m = 2 * l;
986e461dc072 Initial revision
glantau
parents:
diff changeset
932 if (val < -l) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
933 val += m;
986e461dc072 Initial revision
glantau
parents:
diff changeset
934 } else if (val >= l) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
935 val -= m;
986e461dc072 Initial revision
glantau
parents:
diff changeset
936 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
937
986e461dc072 Initial revision
glantau
parents:
diff changeset
938 if (val >= 0) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
939 sign = 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
940 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
941 val = -val;
986e461dc072 Initial revision
glantau
parents:
diff changeset
942 sign = 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
943 }
312
8cf5507e6ca5 mpeg4 mpeg quantizer support
michaelni
parents: 301
diff changeset
944 val--;
8cf5507e6ca5 mpeg4 mpeg quantizer support
michaelni
parents: 301
diff changeset
945 code = (val >> bit_size) + 1;
8cf5507e6ca5 mpeg4 mpeg quantizer support
michaelni
parents: 301
diff changeset
946 bits = val & (range - 1);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
947
986e461dc072 Initial revision
glantau
parents:
diff changeset
948 put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign);
986e461dc072 Initial revision
glantau
parents:
diff changeset
949 if (bit_size > 0) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
950 put_bits(&s->pb, bit_size, bits);
986e461dc072 Initial revision
glantau
parents:
diff changeset
951 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
952 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
953 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
954
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
955 /* Encode MV differences on H.263+ with Unrestricted MV mode */
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
956 static void h263p_encode_umotion(MpegEncContext * s, int val)
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
957 {
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
958 short sval = 0;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
959 short i = 0;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
960 short n_bits = 0;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
961 short temp_val;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
962 int code = 0;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
963 int tcode;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
964
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
965 if ( val == 0)
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
966 put_bits(&s->pb, 1, 1);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
967 else if (val == 1)
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
968 put_bits(&s->pb, 3, 0);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
969 else if (val == -1)
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
970 put_bits(&s->pb, 3, 2);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
971 else {
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
972
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
973 sval = ((val < 0) ? (short)(-val):(short)val);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
974 temp_val = sval;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
975
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
976 while (temp_val != 0) {
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
977 temp_val = temp_val >> 1;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
978 n_bits++;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
979 }
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
980
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
981 i = n_bits - 1;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
982 while (i > 0) {
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
983 tcode = (sval & (1 << (i-1))) >> (i-1);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
984 tcode = (tcode << 1) | 1;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
985 code = (code << 2) | tcode;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
986 i--;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
987 }
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
988 code = ((code << 1) | (val < 0)) << 1;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
989 put_bits(&s->pb, (2*n_bits)+1, code);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
990 //printf("\nVal = %d\tCode = %d", sval, code);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
991 }
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
992 }
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
993
277
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
994 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
995 {
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
996 int f_code;
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
997 int mv;
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
998 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
999 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
1000 int len;
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1001
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1002 if(mv==0) len= mvtab[0][1];
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1003 else{
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1004 int val, bit_size, range, code;
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1005
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1006 bit_size = s->f_code - 1;
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1007 range = 1 << bit_size;
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1008
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1009 val=mv;
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1010 if (val < 0)
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1011 val = -val;
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1012 val--;
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1013 code = (val >> bit_size) + 1;
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1014 if(code<33){
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1015 len= mvtab[code][1] + 1 + bit_size;
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1016 }else{
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1017 len= mvtab[32][1] + 2 + bit_size;
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1018 }
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1019 }
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1020
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1021 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
1022 }
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1023 }
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1024
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1025 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
1026 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
1027 fcode_tab[mv+MAX_MV]= f_code;
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1028 }
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1029 }
287
32a3dcce2e9b fixing motion estimation with h263p hopefully
michaelni
parents: 286
diff changeset
1030
32a3dcce2e9b fixing motion estimation with h263p hopefully
michaelni
parents: 286
diff changeset
1031 for(mv=0; mv<MAX_MV*2+1; mv++){
32a3dcce2e9b fixing motion estimation with h263p hopefully
michaelni
parents: 286
diff changeset
1032 umv_fcode_tab[mv]= 1;
32a3dcce2e9b fixing motion estimation with h263p hopefully
michaelni
parents: 286
diff changeset
1033 }
277
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1034 }
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1035
468
1e23eae32087 Minor warning cleanup.
mellum
parents: 453
diff changeset
1036 static void init_uni_dc_tab(void)
293
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1037 {
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1038 int level, uni_code, uni_len;
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1039
312
8cf5507e6ca5 mpeg4 mpeg quantizer support
michaelni
parents: 301
diff changeset
1040 for(level=-256; level<256; level++){
293
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1041 int size, v, l;
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1042 /* find number of bits */
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1043 size = 0;
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1044 v = abs(level);
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1045 while (v) {
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1046 v >>= 1;
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1047 size++;
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1048 }
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1049
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1050 if (level < 0)
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1051 l= (-level) ^ ((1 << size) - 1);
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1052 else
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1053 l= level;
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1054
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1055 /* luminance */
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1056 uni_code= DCtab_lum[size][0];
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1057 uni_len = DCtab_lum[size][1];
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1058
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1059 if (size > 0) {
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1060 uni_code<<=size; uni_code|=l;
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1061 uni_len+=size;
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1062 if (size > 8){
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1063 uni_code<<=1; uni_code|=1;
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1064 uni_len++;
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1065 }
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1066 }
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1067 uni_DCtab_lum[level+256][0]= uni_code;
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1068 uni_DCtab_lum[level+256][1]= uni_len;
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1069
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1070 /* chrominance */
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1071 uni_code= DCtab_chrom[size][0];
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1072 uni_len = DCtab_chrom[size][1];
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1073
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1074 if (size > 0) {
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1075 uni_code<<=size; uni_code|=l;
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1076 uni_len+=size;
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1077 if (size > 8){
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1078 uni_code<<=1; uni_code|=1;
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1079 uni_len++;
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1080 }
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1081 }
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1082 uni_DCtab_chrom[level+256][0]= uni_code;
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1083 uni_DCtab_chrom[level+256][1]= uni_len;
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1084
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1085 }
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1086 }
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1087
277
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1088 void h263_encode_init(MpegEncContext *s)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1089 {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1090 static int done = 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1091
986e461dc072 Initial revision
glantau
parents:
diff changeset
1092 if (!done) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1093 done = 1;
293
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1094
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1095 init_uni_dc_tab();
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1096
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1097 init_rl(&rl_inter);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1098 init_rl(&rl_intra);
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1099 init_rl(&rl_intra_aic);
277
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1100
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1101 init_mv_penalty_and_fcode(s);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1102 }
287
32a3dcce2e9b fixing motion estimation with h263p hopefully
michaelni
parents: 286
diff changeset
1103 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
1104
287
32a3dcce2e9b fixing motion estimation with h263p hopefully
michaelni
parents: 286
diff changeset
1105 // use fcodes >1 only for mpeg4 & h263 & h263p FIXME
344
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
1106 switch(s->codec_id){
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
1107 case CODEC_ID_MPEG4:
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
1108 s->fcode_tab= fcode_tab;
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
1109 s->min_qcoeff= -2048;
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
1110 s->max_qcoeff= 2047;
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
1111 break;
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
1112 case CODEC_ID_H263P:
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
1113 s->fcode_tab= umv_fcode_tab;
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
1114 s->min_qcoeff= -128;
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
1115 s->max_qcoeff= 127;
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
1116 break;
498
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
1117 //Note for mpeg4 & h263 the dc-scale table will be set per frame as needed later
344
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
1118 default: //nothing needed default table allready set in mpegvideo.c
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
1119 s->min_qcoeff= -128;
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
1120 s->max_qcoeff= 127;
498
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
1121 s->y_dc_scale_table=
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
1122 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
344
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
1123 }
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
1124
599
b1a191202f96 mpeg4 mpeg quantizer encoding
michaelni
parents: 598
diff changeset
1125 if(s->mpeg_quant){
b1a191202f96 mpeg4 mpeg quantizer encoding
michaelni
parents: 598
diff changeset
1126 s->intra_quant_bias= 3<<(QUANT_BIAS_SHIFT-3); //(a + x*3/8)/x
b1a191202f96 mpeg4 mpeg quantizer encoding
michaelni
parents: 598
diff changeset
1127 s->inter_quant_bias= 0;
b1a191202f96 mpeg4 mpeg quantizer encoding
michaelni
parents: 598
diff changeset
1128 }else{
b1a191202f96 mpeg4 mpeg quantizer encoding
michaelni
parents: 598
diff changeset
1129 s->intra_quant_bias=0;
b1a191202f96 mpeg4 mpeg quantizer encoding
michaelni
parents: 598
diff changeset
1130 s->inter_quant_bias=-(1<<(QUANT_BIAS_SHIFT-2)); //(a - x/4)/x
b1a191202f96 mpeg4 mpeg quantizer encoding
michaelni
parents: 598
diff changeset
1131 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1132 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1133
986e461dc072 Initial revision
glantau
parents:
diff changeset
1134 static void h263_encode_block(MpegEncContext * s, DCTELEM * block, int n)
986e461dc072 Initial revision
glantau
parents:
diff changeset
1135 {
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1136 int level, run, last, i, j, last_index, last_non_zero, sign, slevel, code;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1137 RLTable *rl;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1138
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1139 rl = &rl_inter;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1140 if (s->mb_intra && !s->h263_aic) {
231
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
1141 /* DC coef */
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
1142 level = block[0];
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1143 /* 255 cannot be represented, so we clamp */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1144 if (level > 254) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1145 level = 254;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1146 block[0] = 254;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1147 }
231
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
1148 /* 0 cannot be represented also */
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
1149 else if (!level) {
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
1150 level = 1;
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
1151 block[0] = 1;
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
1152 }
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
1153 if (level == 128)
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
1154 put_bits(&s->pb, 8, 0xff);
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
1155 else
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
1156 put_bits(&s->pb, 8, level & 0xff);
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
1157 i = 1;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1158 } else {
231
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
1159 i = 0;
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1160 if (s->h263_aic && s->mb_intra)
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1161 rl = &rl_intra_aic;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1162 }
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1163
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1164 /* AC coefs */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1165 last_index = s->block_last_index[n];
986e461dc072 Initial revision
glantau
parents:
diff changeset
1166 last_non_zero = i - 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1167 for (; i <= last_index; i++) {
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1168 j = zigzag_direct[i];
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1169 level = block[j];
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1170 if (level) {
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1171 run = i - last_non_zero - 1;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1172 last = (i == last_index);
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1173 sign = 0;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1174 slevel = level;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1175 if (level < 0) {
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1176 sign = 1;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1177 level = -level;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1178 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1179 code = get_rl_index(rl, last, run, level);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1180 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1181 if (code == rl->n) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1182 put_bits(&s->pb, 1, last);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1183 put_bits(&s->pb, 6, run);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1184 put_bits(&s->pb, 8, slevel & 0xff);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1185 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1186 put_bits(&s->pb, 1, sign);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1187 }
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1188 last_non_zero = i;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1189 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1190 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1191 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1192
986e461dc072 Initial revision
glantau
parents:
diff changeset
1193 /***************************************************/
986e461dc072 Initial revision
glantau
parents:
diff changeset
1194
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1195 void ff_mpeg4_stuffing(PutBitContext * pbc)
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1196 {
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1197 int length;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1198 put_bits(pbc, 1, 0);
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1199 length= (-get_bit_count(pbc))&7;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1200 if(length) put_bits(pbc, length, (1<<length)-1);
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1201 }
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1202
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
1203 /* must be called before writing the header */
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
1204 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
1205 int time_div, time_mod;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
1206
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
1207 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
1208 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
1209 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
1210
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
1211 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
1212 }
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
1213
429
718a22dc121f license/copyright change
glantau
parents: 396
diff changeset
1214 s->time= picture_number*(INT64)FRAME_RATE_BASE*s->time_increment_resolution/s->frame_rate;
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
1215 time_div= s->time/s->time_increment_resolution;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
1216 time_mod= s->time%s->time_increment_resolution;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
1217
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
1218 if(s->pict_type==B_TYPE){
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
1219 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
1220 }else{
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
1221 s->last_time_base= s->time_base;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
1222 s->time_base= time_div;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
1223 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
1224 s->last_non_b_time= s->time;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
1225 }
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
1226 }
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
1227
263
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1228 static void mpeg4_encode_vol_header(MpegEncContext * s)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1229 {
263
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1230 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
1231 char buf[255];
336
c56b45669214 export delay info
michaelni
parents: 335
diff changeset
1232
c56b45669214 export delay info
michaelni
parents: 335
diff changeset
1233 s->vo_type= s->has_b_frames ? CORE_VO_TYPE : SIMPLE_VO_TYPE;
c56b45669214 export delay info
michaelni
parents: 335
diff changeset
1234
263
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1235 put_bits(&s->pb, 16, 0);
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1236 put_bits(&s->pb, 16, 0x100); /* video obj */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1237 put_bits(&s->pb, 16, 0);
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1238 put_bits(&s->pb, 16, 0x120); /* video obj layer */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1239
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1240 put_bits(&s->pb, 1, 0); /* random access vol */
336
c56b45669214 export delay info
michaelni
parents: 335
diff changeset
1241 put_bits(&s->pb, 8, s->vo_type); /* video obj type indication */
263
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1242 put_bits(&s->pb, 1, 1); /* is obj layer id= yes */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1243 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
1244 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
1245 if(s->aspect_ratio_info)
1fc96b02142e mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents: 278
diff changeset
1246 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
1247 else
1fc96b02142e mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents: 278
diff changeset
1248 put_bits(&s->pb, 4, 1); /* aspect ratio info= sqare pixel */
336
c56b45669214 export delay info
michaelni
parents: 335
diff changeset
1249
c56b45669214 export delay info
michaelni
parents: 335
diff changeset
1250 if(s->low_delay){
c56b45669214 export delay info
michaelni
parents: 335
diff changeset
1251 put_bits(&s->pb, 1, 1); /* vol control parameters= yes */
341
bf26081c373c avcodec_flush_buffers()
michaelni
parents: 339
diff changeset
1252 put_bits(&s->pb, 2, 1); /* chroma format YUV 420/YV12 */
336
c56b45669214 export delay info
michaelni
parents: 335
diff changeset
1253 put_bits(&s->pb, 1, s->low_delay);
c56b45669214 export delay info
michaelni
parents: 335
diff changeset
1254 put_bits(&s->pb, 1, 0); /* vbv parameters= no */
c56b45669214 export delay info
michaelni
parents: 335
diff changeset
1255 }else{
c56b45669214 export delay info
michaelni
parents: 335
diff changeset
1256 put_bits(&s->pb, 1, 0); /* vol control parameters= no */
c56b45669214 export delay info
michaelni
parents: 335
diff changeset
1257 }
c56b45669214 export delay info
michaelni
parents: 335
diff changeset
1258
263
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1259 put_bits(&s->pb, 2, RECT_SHAPE); /* vol shape= rectangle */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1260 put_bits(&s->pb, 1, 1); /* marker bit */
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
1261
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
1262 put_bits(&s->pb, 16, s->time_increment_resolution);
263
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1263 if (s->time_increment_bits < 1)
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1264 s->time_increment_bits = 1;
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1265 put_bits(&s->pb, 1, 1); /* marker bit */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1266 put_bits(&s->pb, 1, 0); /* fixed vop rate=no */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1267 put_bits(&s->pb, 1, 1); /* marker bit */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1268 put_bits(&s->pb, 13, s->width); /* vol width */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1269 put_bits(&s->pb, 1, 1); /* marker bit */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1270 put_bits(&s->pb, 13, s->height); /* vol height */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1271 put_bits(&s->pb, 1, 1); /* marker bit */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1272 put_bits(&s->pb, 1, 0); /* interlace */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1273 put_bits(&s->pb, 1, 1); /* obmc disable */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1274 if (vo_ver_id == 1) {
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1275 put_bits(&s->pb, 1, s->vol_sprite_usage=0); /* sprite enable */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1276 }else{ /* vo_ver_id == 2 */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1277 put_bits(&s->pb, 2, s->vol_sprite_usage=0); /* sprite enable */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1278 }
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1279 put_bits(&s->pb, 1, 0); /* not 8 bit */
599
b1a191202f96 mpeg4 mpeg quantizer encoding
michaelni
parents: 598
diff changeset
1280 put_bits(&s->pb, 1, s->mpeg_quant); /* quant type= (0=h263 style)*/
b1a191202f96 mpeg4 mpeg quantizer encoding
michaelni
parents: 598
diff changeset
1281 if(s->mpeg_quant) put_bits(&s->pb, 2, 0); /* no custom matrixes */
b1a191202f96 mpeg4 mpeg quantizer encoding
michaelni
parents: 598
diff changeset
1282
263
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1283 if (vo_ver_id != 1)
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1284 put_bits(&s->pb, 1, s->quarter_sample=0);
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1285 put_bits(&s->pb, 1, 1); /* complexity estimation disable */
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1286 s->resync_marker= s->rtp_mode;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1287 put_bits(&s->pb, 1, s->resync_marker ? 0 : 1);/* resync marker disable */
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1288 put_bits(&s->pb, 1, s->data_partitioning ? 1 : 0);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1289 if(s->data_partitioning){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1290 put_bits(&s->pb, 1, 0); /* no rvlc */
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1291 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1292
263
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1293 if (vo_ver_id != 1){
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1294 put_bits(&s->pb, 1, 0); /* newpred */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1295 put_bits(&s->pb, 1, 0); /* reduced res vop */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1296 }
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1297 put_bits(&s->pb, 1, 0); /* scalability */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1298
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1299 ff_mpeg4_stuffing(&s->pb);
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1300 put_bits(&s->pb, 16, 0);
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1301 put_bits(&s->pb, 16, 0x1B2); /* user_data */
360
71792167020c shorter user data with formating by juanjo
michaelni
parents: 359
diff changeset
1302 sprintf(buf, "FFmpeg%sb%s", FFMPEG_VERSION, LIBAVCODEC_BUILD_STR);
322
ce35fd27bbb0 - Versions defined for libav/libavcodec.
pulento
parents: 312
diff changeset
1303 put_string(&s->pb, buf);
264
28c5c62b1c4c support decoding (with mplayer) of 3 .mp4 files from mphq
michaelni
parents: 263
diff changeset
1304
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1305 ff_mpeg4_stuffing(&s->pb);
263
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1306 }
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1307
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1308 /* write mpeg4 VOP header */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1309 void mpeg4_encode_picture_header(MpegEncContext * s, int picture_number)
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1310 {
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
1311 int time_incr;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
1312 int time_div, time_mod;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
1313
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1314 if(s->pict_type==I_TYPE){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1315 s->no_rounding=0;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1316 if(picture_number==0 || !s->strict_std_compliance)
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1317 mpeg4_encode_vol_header(s);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1318 }
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
1319
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
1320 //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
1321
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
1322 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
1323 put_bits(&s->pb, 16, 0x1B6); /* vop header */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1324 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
1325
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
1326 time_div= s->time/s->time_increment_resolution;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
1327 time_mod= s->time%s->time_increment_resolution;
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
1328 time_incr= time_div - s->last_time_base;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
1329 while(time_incr--)
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
1330 put_bits(&s->pb, 1, 1);
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
1331
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1332 put_bits(&s->pb, 1, 0);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1333
986e461dc072 Initial revision
glantau
parents:
diff changeset
1334 put_bits(&s->pb, 1, 1); /* marker */
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
1335 put_bits(&s->pb, s->time_increment_bits, time_mod); /* time increment */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1336 put_bits(&s->pb, 1, 1); /* marker */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1337 put_bits(&s->pb, 1, 1); /* vop coded */
263
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1338 if ( s->pict_type == P_TYPE
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1339 || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE)) {
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1340 s->no_rounding ^= 1;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1341 put_bits(&s->pb, 1, s->no_rounding); /* rounding type */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1342 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1343 put_bits(&s->pb, 3, 0); /* intra dc VLC threshold */
263
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1344 //FIXME sprite stuff
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1345
986e461dc072 Initial revision
glantau
parents:
diff changeset
1346 put_bits(&s->pb, 5, s->qscale);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1347
986e461dc072 Initial revision
glantau
parents:
diff changeset
1348 if (s->pict_type != I_TYPE)
986e461dc072 Initial revision
glantau
parents:
diff changeset
1349 put_bits(&s->pb, 3, s->f_code); /* fcode_for */
263
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1350 if (s->pict_type == B_TYPE)
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1351 put_bits(&s->pb, 3, s->b_code); /* fcode_back */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1352 // printf("****frame %d\n", picture_number);
498
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
1353
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
1354 s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table; //FIXME add short header support
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
1355 s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
582
5132a4ee50cd different edge positions fixed with edge emu / dr1
michaelni
parents: 575
diff changeset
1356 s->h_edge_pos= s->width;
5132a4ee50cd different edge positions fixed with edge emu / dr1
michaelni
parents: 575
diff changeset
1357 s->v_edge_pos= s->height;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1358 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1359
498
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
1360 static void h263_dc_scale(MpegEncContext * s)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1361 {
498
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
1362 s->y_dc_scale= s->y_dc_scale_table[ s->qscale ];
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
1363 s->c_dc_scale= s->c_dc_scale_table[ s->qscale ];
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1364 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1365
498
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
1366 inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, UINT16 **dc_val_ptr, int *dir_ptr)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1367 {
266
252444e5259b optimization
michaelni
parents: 265
diff changeset
1368 int a, b, c, wrap, pred, scale;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1369 UINT16 *dc_val;
469
a5dd4eae1f0c Revert previous bogus warning fix.
mellum
parents: 468
diff changeset
1370 int dummy;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1371
986e461dc072 Initial revision
glantau
parents:
diff changeset
1372 /* find prediction */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1373 if (n < 4) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1374 scale = s->y_dc_scale;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1375 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1376 scale = s->c_dc_scale;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1377 }
266
252444e5259b optimization
michaelni
parents: 265
diff changeset
1378 wrap= s->block_wrap[n];
252444e5259b optimization
michaelni
parents: 265
diff changeset
1379 dc_val = s->dc_val[0] + s->block_index[n];
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1380
986e461dc072 Initial revision
glantau
parents:
diff changeset
1381 /* B C
986e461dc072 Initial revision
glantau
parents:
diff changeset
1382 * A X
986e461dc072 Initial revision
glantau
parents:
diff changeset
1383 */
266
252444e5259b optimization
michaelni
parents: 265
diff changeset
1384 a = dc_val[ - 1];
252444e5259b optimization
michaelni
parents: 265
diff changeset
1385 b = dc_val[ - 1 - wrap];
252444e5259b optimization
michaelni
parents: 265
diff changeset
1386 c = dc_val[ - wrap];
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1387
986e461dc072 Initial revision
glantau
parents:
diff changeset
1388 if (abs(a - b) < abs(b - c)) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1389 pred = c;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1390 *dir_ptr = 1; /* top */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1391 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1392 pred = a;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1393 *dir_ptr = 0; /* left */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1394 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1395 /* we assume pred is positive */
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1396 #ifdef ARCH_X86
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1397 asm volatile (
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1398 "xorl %%edx, %%edx \n\t"
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1399 "mul %%ecx \n\t"
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1400 : "=d" (pred), "=a"(dummy)
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1401 : "a" (pred + (scale >> 1)), "c" (inverse[scale])
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1402 );
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1403 #else
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1404 pred = (pred + (scale >> 1)) / scale;
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1405 #endif
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1406
986e461dc072 Initial revision
glantau
parents:
diff changeset
1407 /* prepare address for prediction update */
266
252444e5259b optimization
michaelni
parents: 265
diff changeset
1408 *dc_val_ptr = &dc_val[0];
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1409
986e461dc072 Initial revision
glantau
parents:
diff changeset
1410 return pred;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1411 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1412
174
ac5075a55488 new IDCT code by Michael Niedermayer (michaelni@gmx.at) - #define SIMPLE_IDCT to enable
arpi_esp
parents: 162
diff changeset
1413 void mpeg4_pred_ac(MpegEncContext * s, INT16 *block, int n,
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1414 int dir)
986e461dc072 Initial revision
glantau
parents:
diff changeset
1415 {
266
252444e5259b optimization
michaelni
parents: 265
diff changeset
1416 int i;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1417 INT16 *ac_val, *ac_val1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1418
986e461dc072 Initial revision
glantau
parents:
diff changeset
1419 /* find prediction */
266
252444e5259b optimization
michaelni
parents: 265
diff changeset
1420 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1421 ac_val1 = ac_val;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1422 if (s->ac_pred) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1423 if (dir == 0) {
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
1424 const int xy= s->mb_x-1 + s->mb_y*s->mb_width;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1425 /* left prediction */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1426 ac_val -= 16;
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
1427
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
1428 if(s->mb_x==0 || s->qscale == s->qscale_table[xy] || n==1 || n==3){
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
1429 /* same qscale */
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
1430 for(i=1;i<8;i++) {
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
1431 block[block_permute_op(i*8)] += ac_val[i];
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
1432 }
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
1433 }else{
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
1434 /* different qscale, we must rescale */
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
1435 for(i=1;i<8;i++) {
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
1436 block[block_permute_op(i*8)] += ROUNDED_DIV(ac_val[i]*s->qscale_table[xy], s->qscale);
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
1437 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1438 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1439 } else {
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
1440 const int xy= s->mb_x + s->mb_y*s->mb_width - s->mb_width;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1441 /* top prediction */
266
252444e5259b optimization
michaelni
parents: 265
diff changeset
1442 ac_val -= 16 * s->block_wrap[n];
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
1443
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
1444 if(s->mb_y==0 || s->qscale == s->qscale_table[xy] || n==2 || n==3){
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
1445 /* same qscale */
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
1446 for(i=1;i<8;i++) {
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
1447 block[block_permute_op(i)] += ac_val[i + 8];
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
1448 }
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
1449 }else{
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
1450 /* different qscale, we must rescale */
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
1451 for(i=1;i<8;i++) {
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
1452 block[block_permute_op(i)] += ROUNDED_DIV(ac_val[i + 8]*s->qscale_table[xy], s->qscale);
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
1453 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1454 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1455 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1456 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1457 /* left copy */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1458 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
1459 ac_val1[i] = block[block_permute_op(i * 8)];
591
d3f374218030 fixing mpeg4 mpeg quantizers
michaelni
parents: 582
diff changeset
1460
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1461 /* top copy */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1462 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
1463 ac_val1[8 + i] = block[block_permute_op(i)];
591
d3f374218030 fixing mpeg4 mpeg quantizers
michaelni
parents: 582
diff changeset
1464
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1465 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1466
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1467 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
1468 int dir)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1469 {
266
252444e5259b optimization
michaelni
parents: 265
diff changeset
1470 int i;
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1471 INT16 *ac_val;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1472
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1473 /* find prediction */
266
252444e5259b optimization
michaelni
parents: 265
diff changeset
1474 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
1475
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1476 if (dir == 0) {
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1477 /* left prediction */
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1478 ac_val -= 16;
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1479 for(i=1;i<8;i++) {
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1480 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
1481 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1482 } else {
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1483 /* top prediction */
266
252444e5259b optimization
michaelni
parents: 265
diff changeset
1484 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
1485 for(i=1;i<8;i++) {
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1486 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
1487 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1488 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1489 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1490
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1491 static inline void mpeg4_encode_dc(PutBitContext * s, int level, int n)
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1492 {
293
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1493 #if 1
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1494 // if(level<-255 || level>255) printf("dc overflow\n");
293
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1495 level+=256;
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1496 if (n < 4) {
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1497 /* luminance */
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1498 put_bits(s, uni_DCtab_lum[level][1], uni_DCtab_lum[level][0]);
293
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1499 } else {
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1500 /* chrominance */
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1501 put_bits(s, uni_DCtab_chrom[level][1], uni_DCtab_chrom[level][0]);
293
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1502 }
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1503 #else
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1504 int size, v;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1505 /* find number of bits */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1506 size = 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1507 v = abs(level);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1508 while (v) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1509 v >>= 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1510 size++;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1511 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1512
986e461dc072 Initial revision
glantau
parents:
diff changeset
1513 if (n < 4) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1514 /* luminance */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1515 put_bits(&s->pb, DCtab_lum[size][1], DCtab_lum[size][0]);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1516 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1517 /* chrominance */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1518 put_bits(&s->pb, DCtab_chrom[size][1], DCtab_chrom[size][0]);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1519 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1520
986e461dc072 Initial revision
glantau
parents:
diff changeset
1521 /* encode remaining bits */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1522 if (size > 0) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1523 if (level < 0)
986e461dc072 Initial revision
glantau
parents:
diff changeset
1524 level = (-level) ^ ((1 << size) - 1);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1525 put_bits(&s->pb, size, level);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1526 if (size > 8)
986e461dc072 Initial revision
glantau
parents:
diff changeset
1527 put_bits(&s->pb, 1, 1);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1528 }
293
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1529 #endif
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1530 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1531
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1532 static void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n, int intra_dc,
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1533 UINT8 *scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1534 {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1535 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
1536 int code;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1537 const RLTable *rl;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1538
986e461dc072 Initial revision
glantau
parents:
diff changeset
1539 if (s->mb_intra) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1540 /* mpeg4 based DC predictor */
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1541 mpeg4_encode_dc(dc_pb, intra_dc, n);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1542 i = 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1543 rl = &rl_intra;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1544 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1545 i = 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1546 rl = &rl_inter;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1547 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1548
986e461dc072 Initial revision
glantau
parents:
diff changeset
1549 /* AC coefs */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1550 last_index = s->block_last_index[n];
986e461dc072 Initial revision
glantau
parents:
diff changeset
1551 last_non_zero = i - 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1552 for (; i <= last_index; i++) {
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1553 j = scan_table[i];
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1554 level = block[j];
986e461dc072 Initial revision
glantau
parents:
diff changeset
1555 if (level) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1556 run = i - last_non_zero - 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1557 last = (i == last_index);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1558 sign = 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1559 slevel = level;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1560 if (level < 0) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1561 sign = 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1562 level = -level;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1563 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1564 code = get_rl_index(rl, last, run, level);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1565 put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1566 if (code == rl->n) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1567 int level1, run1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1568 level1 = level - rl->max_level[last][run];
986e461dc072 Initial revision
glantau
parents:
diff changeset
1569 if (level1 < 1)
986e461dc072 Initial revision
glantau
parents:
diff changeset
1570 goto esc2;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1571 code = get_rl_index(rl, last, run, level1);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1572 if (code == rl->n) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1573 esc2:
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1574 put_bits(ac_pb, 1, 1);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1575 if (level > MAX_LEVEL)
986e461dc072 Initial revision
glantau
parents:
diff changeset
1576 goto esc3;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1577 run1 = run - rl->max_run[last][level] - 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1578 if (run1 < 0)
986e461dc072 Initial revision
glantau
parents:
diff changeset
1579 goto esc3;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1580 code = get_rl_index(rl, last, run1, level);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1581 if (code == rl->n) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1582 esc3:
986e461dc072 Initial revision
glantau
parents:
diff changeset
1583 /* third escape */
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1584 put_bits(ac_pb, 1, 1);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1585 put_bits(ac_pb, 1, last);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1586 put_bits(ac_pb, 6, run);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1587 put_bits(ac_pb, 1, 1);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1588 put_bits(ac_pb, 12, slevel & 0xfff);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1589 put_bits(ac_pb, 1, 1);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1590 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1591 /* second escape */
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1592 put_bits(ac_pb, 1, 0);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1593 put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1594 put_bits(ac_pb, 1, sign);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1595 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1596 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1597 /* first escape */
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1598 put_bits(ac_pb, 1, 0);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1599 put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1600 put_bits(ac_pb, 1, sign);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1601 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1602 } else {
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1603 put_bits(ac_pb, 1, sign);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1604 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1605 last_non_zero = i;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1606 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1607 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1608 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1609
986e461dc072 Initial revision
glantau
parents:
diff changeset
1610
986e461dc072 Initial revision
glantau
parents:
diff changeset
1611
986e461dc072 Initial revision
glantau
parents:
diff changeset
1612 /***********************************************/
986e461dc072 Initial revision
glantau
parents:
diff changeset
1613 /* decoding */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1614
986e461dc072 Initial revision
glantau
parents:
diff changeset
1615 static VLC intra_MCBPC_vlc;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1616 static VLC inter_MCBPC_vlc;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1617 static VLC cbpy_vlc;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1618 static VLC mv_vlc;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1619 static VLC dc_lum, dc_chrom;
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
1620 static VLC sprite_trajectory;
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1621 static VLC mb_type_b_vlc;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1622
986e461dc072 Initial revision
glantau
parents:
diff changeset
1623 void init_rl(RLTable *rl)
986e461dc072 Initial revision
glantau
parents:
diff changeset
1624 {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1625 INT8 max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
986e461dc072 Initial revision
glantau
parents:
diff changeset
1626 UINT8 index_run[MAX_RUN+1];
986e461dc072 Initial revision
glantau
parents:
diff changeset
1627 int last, run, level, start, end, i;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1628
986e461dc072 Initial revision
glantau
parents:
diff changeset
1629 /* compute max_level[], max_run[] and index_run[] */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1630 for(last=0;last<2;last++) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1631 if (last == 0) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1632 start = 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1633 end = rl->last;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1634 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1635 start = rl->last;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1636 end = rl->n;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1637 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1638
986e461dc072 Initial revision
glantau
parents:
diff changeset
1639 memset(max_level, 0, MAX_RUN + 1);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1640 memset(max_run, 0, MAX_LEVEL + 1);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1641 memset(index_run, rl->n, MAX_RUN + 1);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1642 for(i=start;i<end;i++) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1643 run = rl->table_run[i];
986e461dc072 Initial revision
glantau
parents:
diff changeset
1644 level = rl->table_level[i];
986e461dc072 Initial revision
glantau
parents:
diff changeset
1645 if (index_run[run] == rl->n)
986e461dc072 Initial revision
glantau
parents:
diff changeset
1646 index_run[run] = i;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1647 if (level > max_level[run])
986e461dc072 Initial revision
glantau
parents:
diff changeset
1648 max_level[run] = level;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1649 if (run > max_run[level])
986e461dc072 Initial revision
glantau
parents:
diff changeset
1650 max_run[level] = run;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1651 }
396
fce0a2520551 removed useless header includes - use av memory functions
glantau
parents: 365
diff changeset
1652 rl->max_level[last] = av_malloc(MAX_RUN + 1);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1653 memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
396
fce0a2520551 removed useless header includes - use av memory functions
glantau
parents: 365
diff changeset
1654 rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1655 memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
396
fce0a2520551 removed useless header includes - use av memory functions
glantau
parents: 365
diff changeset
1656 rl->index_run[last] = av_malloc(MAX_RUN + 1);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1657 memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1658 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1659 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1660
986e461dc072 Initial revision
glantau
parents:
diff changeset
1661 void init_vlc_rl(RLTable *rl)
986e461dc072 Initial revision
glantau
parents:
diff changeset
1662 {
542
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
1663 int i, q;
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
1664
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1665 init_vlc(&rl->vlc, 9, rl->n + 1,
986e461dc072 Initial revision
glantau
parents:
diff changeset
1666 &rl->table_vlc[0][1], 4, 2,
986e461dc072 Initial revision
glantau
parents:
diff changeset
1667 &rl->table_vlc[0][0], 4, 2);
542
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
1668
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
1669
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
1670 for(q=0; q<32; q++){
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
1671 int qmul= q*2;
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
1672 int qadd= (q-1)|1;
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
1673
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
1674 if(q==0){
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
1675 qmul=1;
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
1676 qadd=0;
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
1677 }
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
1678
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
1679 rl->rl_vlc[q]= av_malloc(rl->vlc.table_size*sizeof(RL_VLC_ELEM));
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
1680 for(i=0; i<rl->vlc.table_size; i++){
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
1681 int code= rl->vlc.table[i][0];
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
1682 int len = rl->vlc.table[i][1];
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
1683 int level, run;
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
1684
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
1685 if(len==0){ // illegal code
563
61442627f857 fixes fire.avi & subtitles.avi
michaelni
parents: 549
diff changeset
1686 run= 66;
542
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
1687 level= MAX_LEVEL;
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
1688 }else if(len<0){ //more bits needed
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
1689 run= 0;
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
1690 level= code;
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
1691 }else{
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
1692 if(code==rl->n){ //esc
563
61442627f857 fixes fire.avi & subtitles.avi
michaelni
parents: 549
diff changeset
1693 run= 66;
542
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
1694 level= 0;
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
1695 }else{
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
1696 run= rl->table_run [code] + 1;
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
1697 level= rl->table_level[code] * qmul + qadd;
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
1698 if(code >= rl->last) run+=192;
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
1699 }
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
1700 }
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
1701 rl->rl_vlc[q][i].len= len;
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
1702 rl->rl_vlc[q][i].level= level;
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
1703 rl->rl_vlc[q][i].run= run;
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
1704 }
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
1705 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1706 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1707
986e461dc072 Initial revision
glantau
parents:
diff changeset
1708 /* init vlcs */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1709
986e461dc072 Initial revision
glantau
parents:
diff changeset
1710 /* XXX: find a better solution to handle static init */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1711 void h263_decode_init_vlc(MpegEncContext *s)
986e461dc072 Initial revision
glantau
parents:
diff changeset
1712 {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1713 static int done = 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1714
986e461dc072 Initial revision
glantau
parents:
diff changeset
1715 if (!done) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1716 done = 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1717
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
1718 init_vlc(&intra_MCBPC_vlc, INTRA_MCBPC_VLC_BITS, 8,
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1719 intra_MCBPC_bits, 1, 1,
986e461dc072 Initial revision
glantau
parents:
diff changeset
1720 intra_MCBPC_code, 1, 1);
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
1721 init_vlc(&inter_MCBPC_vlc, INTER_MCBPC_VLC_BITS, 25,
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1722 inter_MCBPC_bits, 1, 1,
986e461dc072 Initial revision
glantau
parents:
diff changeset
1723 inter_MCBPC_code, 1, 1);
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
1724 init_vlc(&cbpy_vlc, CBPY_VLC_BITS, 16,
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1725 &cbpy_tab[0][1], 2, 1,
986e461dc072 Initial revision
glantau
parents:
diff changeset
1726 &cbpy_tab[0][0], 2, 1);
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
1727 init_vlc(&mv_vlc, MV_VLC_BITS, 33,
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1728 &mvtab[0][1], 2, 1,
986e461dc072 Initial revision
glantau
parents:
diff changeset
1729 &mvtab[0][0], 2, 1);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1730 init_rl(&rl_inter);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1731 init_rl(&rl_intra);
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1732 init_rl(&rl_intra_aic);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1733 init_vlc_rl(&rl_inter);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1734 init_vlc_rl(&rl_intra);
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1735 init_vlc_rl(&rl_intra_aic);
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
1736 init_vlc(&dc_lum, DC_VLC_BITS, 10 /* 13 */,
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1737 &DCtab_lum[0][1], 2, 1,
986e461dc072 Initial revision
glantau
parents:
diff changeset
1738 &DCtab_lum[0][0], 2, 1);
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
1739 init_vlc(&dc_chrom, DC_VLC_BITS, 10 /* 13 */,
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1740 &DCtab_chrom[0][1], 2, 1,
986e461dc072 Initial revision
glantau
parents:
diff changeset
1741 &DCtab_chrom[0][0], 2, 1);
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
1742 init_vlc(&sprite_trajectory, SPRITE_TRAJ_VLC_BITS, 15,
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
1743 &sprite_trajectory_tab[0][1], 4, 2,
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
1744 &sprite_trajectory_tab[0][0], 4, 2);
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
1745 init_vlc(&mb_type_b_vlc, MB_TYPE_B_VLC_BITS, 4,
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1746 &mb_type_b_tab[0][1], 2, 1,
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1747 &mb_type_b_tab[0][0], 2, 1);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1748 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1749 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1750
162
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
1751 int h263_decode_gob_header(MpegEncContext *s)
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
1752 {
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
1753 unsigned int val, gfid;
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
1754
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
1755 /* Check for GOB Start Code */
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
1756 val = show_bits(&s->gb, 16);
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
1757 if (val == 0) {
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
1758 /* We have a GBSC probably with GSTUFF */
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
1759 skip_bits(&s->gb, 16); /* Drop the zeros */
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
1760 while (get_bits1(&s->gb) == 0); /* Seek the '1' bit */
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
1761 #ifdef DEBUG
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
1762 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
1763 #endif
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
1764 s->gob_number = get_bits(&s->gb, 5); /* GN */
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
1765 gfid = get_bits(&s->gb, 2); /* GFID */
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
1766 s->qscale = get_bits(&s->gb, 5); /* GQUANT */
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
1767 #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
1768 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
1769 #endif
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
1770 return 1;
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
1771 }
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
1772 return 0;
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
1773
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
1774 }
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
1775
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
1776 static inline void memsetw(short *tab, int val, int n)
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
1777 {
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
1778 int i;
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
1779 for(i=0;i<n;i++)
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
1780 tab[i] = val;
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
1781 }
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
1782
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1783 void ff_mpeg4_init_partitions(MpegEncContext *s)
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1784 {
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1785 init_put_bits(&s->tex_pb, s->tex_pb_buffer, PB_BUFFER_SIZE, NULL, NULL);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1786 init_put_bits(&s->pb2 , s->pb2_buffer , PB_BUFFER_SIZE, NULL, NULL);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1787 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1788
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1789 void ff_mpeg4_merge_partitions(MpegEncContext *s)
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
1790 {
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1791 const int pb2_len = get_bit_count(&s->pb2 );
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1792 const int tex_pb_len= get_bit_count(&s->tex_pb);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1793 const int bits= get_bit_count(&s->pb);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1794
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1795 if(s->pict_type==I_TYPE){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1796 put_bits(&s->pb, 19, DC_MARKER);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1797 s->misc_bits+=19 + pb2_len + bits - s->last_bits;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1798 s->i_tex_bits+= tex_pb_len;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1799 }else{
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1800 put_bits(&s->pb, 17, MOTION_MARKER);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1801 s->misc_bits+=17 + pb2_len;;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1802 s->mv_bits+= bits - s->last_bits;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1803 s->p_tex_bits+= tex_pb_len;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1804 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1805
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1806 flush_put_bits(&s->pb2);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1807 flush_put_bits(&s->tex_pb);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1808
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1809 ff_copy_bits(&s->pb, s->pb2_buffer , pb2_len);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1810 ff_copy_bits(&s->pb, s->tex_pb_buffer, tex_pb_len);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1811 s->last_bits= get_bit_count(&s->pb);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1812 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1813
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1814 void ff_mpeg4_encode_video_packet_header(MpegEncContext *s)
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1815 {
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1816 int mb_num_bits= av_log2(s->mb_num - 1) + 1;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1817
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1818 ff_mpeg4_stuffing(&s->pb);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1819 if(s->pict_type==I_TYPE)
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1820 put_bits(&s->pb, 16, 0);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1821 else if(s->pict_type==B_TYPE)
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1822 put_bits(&s->pb, MAX(MAX(s->f_code, s->b_code)+15, 17), 0);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1823 else /* S/P_TYPE */
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1824 put_bits(&s->pb, s->f_code+15, 0);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1825 put_bits(&s->pb, 1, 1);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1826
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1827 put_bits(&s->pb, mb_num_bits, s->mb_x + s->mb_y*s->mb_width);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1828 put_bits(&s->pb, 5, s->qscale);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1829 put_bits(&s->pb, 1, 0); /* no HEC */
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1830 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1831
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1832 /**
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1833 * decodes the next video packet and sets s->next_qscale
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1834 * returns mb_num of the next packet or <0 if something went wrong
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1835 */
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1836 static int decode_video_packet_header(MpegEncContext *s, GetBitContext *gb)
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1837 {
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1838 int bits;
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
1839 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
1840 int header_extension=0, mb_num;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1841 //printf("%X\n", show_bits(&gb, 24));
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1842 //printf("parse_video_packet_header\n");
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1843 // if(show_aligned_bits(gb, 1, 16) != 0) return -1;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1844
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1845 /* is there enough space left for a video packet + header */
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1846 if( get_bits_count(gb) > gb->size*8-20) return -1;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1847
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
1848 //printf("resync at %d %d\n", s->mb_x, s->mb_y);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1849 // skip_bits(gb, 1);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1850 // align_get_bits(gb);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1851 if(get_bits(gb, 16)!=0){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1852 printf("internal error while decoding video packet header\n");
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1853 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1854
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1855 //printf("%X\n", show_bits(gb, 24));
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1856 bits=0;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1857 while(!get_bits1(gb) && bits<30) bits++;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1858 if((s->pict_type == P_TYPE || s->pict_type == S_TYPE) && bits != s->f_code-1){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1859 printf("marker does not match f_code (is: %d should be: %d pos: %d end %d x: %d y: %d)\n",
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1860 bits+1, s->f_code, get_bits_count(gb), gb->size*8, s->mb_x, s->mb_y);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1861 return -1;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1862 }else if(s->pict_type == I_TYPE && bits != 0){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1863 printf("marker too long\n");
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1864 return -1;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1865 }else if(s->pict_type == B_TYPE && bits != MAX(MAX(s->f_code, s->b_code)-1, 1)){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1866 printf("marker does not match f/b_code\n");
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1867 return -1;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1868 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1869 //printf("%X\n", show_bits(gb, 24));
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1870
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1871 if(s->shape != RECT_SHAPE){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1872 header_extension= get_bits1(gb);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1873 //FIXME more stuff here
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1874 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1875
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1876 mb_num= get_bits(gb, mb_num_bits);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1877 if(mb_num < s->mb_x + s->mb_y*s->mb_width || mb_num>=s->mb_num){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1878 fprintf(stderr, "illegal mb_num in video packet (%d %d) \n", mb_num, s->mb_x + s->mb_y*s->mb_width);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1879 return -1;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1880 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1881
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1882 if(s->shape != BIN_ONLY_SHAPE){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1883 s->next_resync_qscale= get_bits(gb, 5);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1884 if(s->next_resync_qscale==0)
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1885 s->next_resync_qscale= s->qscale;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1886 if(s->next_resync_qscale==0){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1887 fprintf(stderr, "qscale==0\n");
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
1888 return -1;
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
1889 }
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
1890 }
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
1891
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
1892 if(s->shape == RECT_SHAPE){
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1893 header_extension= get_bits1(gb);
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
1894 }
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
1895 if(header_extension){
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1896 int time_increment;
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
1897 int time_incr=0;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1898 printf("header extension not supported\n");
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1899 return -1;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1900
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1901 while (get_bits1(gb) != 0)
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
1902 time_incr++;
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
1903
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1904 check_marker(gb, "before time_increment in video packed header");
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1905 time_increment= get_bits(gb, s->time_increment_bits);
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
1906 if(s->pict_type!=B_TYPE){
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
1907 s->last_time_base= s->time_base;
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
1908 s->time_base+= time_incr;
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
1909 s->time= s->time_base*s->time_increment_resolution + time_increment;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
1910 s->pp_time= s->time - s->last_non_b_time;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
1911 s->last_non_b_time= s->time;
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
1912 }else{
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
1913 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
1914 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
1915 }
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1916 check_marker(gb, "before vop_coding_type in video packed header");
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
1917
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1918 skip_bits(gb, 2); /* vop coding type */
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
1919 //FIXME not rect stuff here
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
1920
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
1921 if(s->shape != BIN_ONLY_SHAPE){
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1922 skip_bits(gb, 3); /* intra dc vlc threshold */
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
1923
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
1924 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
1925 mpeg4_decode_sprite_trajectory(s);
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
1926 }
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
1927
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
1928 //FIXME reduced res stuff here
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
1929
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
1930 if (s->pict_type != I_TYPE) {
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1931 s->f_code = get_bits(gb, 3); /* fcode_for */
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
1932 if(s->f_code==0){
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
1933 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
1934 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
1935 }
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
1936 }
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
1937 if (s->pict_type == B_TYPE) {
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1938 s->b_code = get_bits(gb, 3);
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
1939 }
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
1940 }
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
1941 }
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
1942 //FIXME new-pred stuff
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1943
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1944 //printf("parse ok %d %d %d %d\n", mb_num, s->mb_x + s->mb_y*s->mb_width, get_bits_count(gb), get_bits_count(&s->gb));
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1945
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1946 return mb_num;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1947 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1948
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1949 void ff_mpeg4_clean_buffers(MpegEncContext *s)
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1950 {
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1951 int c_wrap, c_xy, l_wrap, l_xy;
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
1952
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
1953 l_wrap= s->block_wrap[0];
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1954 l_xy= s->mb_y*l_wrap*2 + s->mb_x*2;
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
1955 c_wrap= s->block_wrap[4];
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1956 c_xy= s->mb_y*c_wrap + s->mb_x;
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
1957
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
1958 /* clean DC */
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1959 memsetw(s->dc_val[0] + l_xy, 1024, l_wrap*2+1);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1960 memsetw(s->dc_val[1] + c_xy, 1024, c_wrap+1);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1961 memsetw(s->dc_val[2] + c_xy, 1024, c_wrap+1);
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
1962
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
1963 /* clean AC */
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1964 memset(s->ac_val[0] + l_xy, 0, (l_wrap*2+1)*16*sizeof(INT16));
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1965 memset(s->ac_val[1] + c_xy, 0, (c_wrap +1)*16*sizeof(INT16));
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1966 memset(s->ac_val[2] + c_xy, 0, (c_wrap +1)*16*sizeof(INT16));
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
1967
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
1968 /* clean MV */
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1969 // we cant clear the MVs as they might be needed by a b frame
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1970 // memset(s->motion_val + l_xy, 0, (l_wrap*2+1)*2*sizeof(INT16));
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
1971 // memset(s->motion_val, 0, 2*sizeof(INT16)*(2 + s->mb_width*2)*(2 + s->mb_height*2));
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1972 s->last_mv[0][0][0]=
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1973 s->last_mv[0][0][1]=
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1974 s->last_mv[1][0][0]=
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1975 s->last_mv[1][0][1]= 0;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1976 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1977
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1978 /* searches for the next resync marker clears ac,dc,mc, and sets s->next_resync_gb, s->mb_num_left */
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1979 int ff_mpeg4_resync(MpegEncContext *s)
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1980 {
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1981 GetBitContext gb;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1982
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1983 /* search & parse next resync marker */
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1984
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1985 gb= s->next_resync_gb;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1986 align_get_bits(&gb);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1987 //printf("mpeg4_resync %d next:%d \n", get_bits_count(&gb), get_bits_count(&s->next_resync_gb));
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1988 for(;;) {
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1989 int v= show_bits(&gb, 24);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1990 if( get_bits_count(&gb) >= gb.size*8-24 || v == 1 /* start-code */){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1991 s->mb_num_left= s->mb_num - s->mb_x - s->mb_y*s->mb_width;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1992 //printf("mpeg4_resync end\n");
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1993 s->gb= s->next_resync_gb; //continue at the next resync marker
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1994 return -1;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1995 }else if(v>>8 == 0){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1996 int next;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1997 s->next_resync_pos= get_bits_count(&gb);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1998
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1999 next= decode_video_packet_header(s, &gb);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2000 if(next >= 0){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2001 s->mb_num_left= next - s->mb_x - s->mb_y*s->mb_width;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2002 break;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2003 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2004
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2005 align_get_bits(&gb);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2006 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2007 skip_bits(&gb, 8);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2008 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2009 s->next_resync_gb=gb;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2010
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2011 return 0;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2012 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2013
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2014 static inline void init_block_index(MpegEncContext *s)
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2015 {
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2016 s->block_index[0]= s->block_wrap[0]*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2017 s->block_index[1]= s->block_wrap[0]*(s->mb_y*2 + 1) + s->mb_x*2;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2018 s->block_index[2]= s->block_wrap[0]*(s->mb_y*2 + 2) - 1 + s->mb_x*2;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2019 s->block_index[3]= s->block_wrap[0]*(s->mb_y*2 + 2) + s->mb_x*2;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2020 s->block_index[4]= s->block_wrap[4]*(s->mb_y + 1) + s->block_wrap[0]*(s->mb_height*2 + 2) + s->mb_x;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2021 s->block_index[5]= s->block_wrap[4]*(s->mb_y + 1 + s->mb_height + 2) + s->block_wrap[0]*(s->mb_height*2 + 2) + s->mb_x;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2022 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2023
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2024 static inline void update_block_index(MpegEncContext *s)
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2025 {
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2026 s->block_index[0]+=2;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2027 s->block_index[1]+=2;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2028 s->block_index[2]+=2;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2029 s->block_index[3]+=2;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2030 s->block_index[4]++;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2031 s->block_index[5]++;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2032 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2033
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2034 /**
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2035 * decodes the first & second partition
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2036 * returns error type or 0 if no error
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2037 */
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2038 int ff_mpeg4_decode_partitions(MpegEncContext *s)
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2039 {
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2040 static const INT8 quant_tab[4] = { -1, -2, 1, 2 };
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2041 int mb_num;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2042
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2043 /* decode first partition */
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2044 mb_num=0;
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2045 s->first_slice_line=1;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2046 s->mb_x= s->resync_mb_x;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2047 for(s->mb_y= s->resync_mb_y; mb_num < s->mb_num_left; s->mb_y++){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2048 init_block_index(s);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2049 for(; mb_num < s->mb_num_left && s->mb_x<s->mb_width; s->mb_x++){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2050 const int xy= s->mb_x + s->mb_y*s->mb_width;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2051 int cbpc;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2052 int dir=0;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2053
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2054 mb_num++;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2055 update_block_index(s);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2056 if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2057 s->first_slice_line=0;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2058
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2059 if(s->mb_x==0) PRINT_MB_TYPE("\n");
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2060
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2061 if(s->pict_type==I_TYPE){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2062 int i;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2063
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2064 PRINT_MB_TYPE("I");
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
2065 cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 1);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2066 if (cbpc < 0){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2067 fprintf(stderr, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2068 return DECODING_DESYNC;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2069 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2070 s->cbp_table[xy]= cbpc & 3;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2071 s->mb_type[xy]= MB_TYPE_INTRA;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2072 s->mb_intra = 1;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2073
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2074 if(cbpc & 4) {
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2075 s->qscale += quant_tab[get_bits(&s->gb, 2)];
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2076 if (s->qscale < 1)
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2077 s->qscale = 1;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2078 else if (s->qscale > 31)
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2079 s->qscale = 31;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2080 h263_dc_scale(s);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2081 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2082 s->qscale_table[xy]= s->qscale;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2083
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2084 s->mbintra_table[xy]= 1;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2085 for(i=0; i<6; i++){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2086 int dc_pred_dir;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2087 int dc= mpeg4_decode_dc(s, i, &dc_pred_dir);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2088 if(dc < 0){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2089 fprintf(stderr, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2090 return DECODING_DESYNC;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2091 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2092 dir<<=1;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2093 if(dc_pred_dir) dir|=1;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2094 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2095 s->pred_dir_table[xy]= dir;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2096 }else{ /* P/S_TYPE */
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2097 int mx, my, pred_x, pred_y;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2098 INT16 * const mot_val= s->motion_val[s->block_index[0]];
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2099 const int stride= s->block_wrap[0]*2;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2100
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2101 if(get_bits1(&s->gb)){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2102 /* skip mb */
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2103 s->mb_type[xy]= MB_TYPE_SKIPED;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2104 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2105 const int a= s->sprite_warping_accuracy;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2106 PRINT_MB_TYPE("G");
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2107 if(s->divx_version==500 && s->divx_build==413){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2108 mx = s->sprite_offset[0][0] / (1<<(a-s->quarter_sample));
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2109 my = s->sprite_offset[0][1] / (1<<(a-s->quarter_sample));
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2110 }else{
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2111 mx = RSHIFT(s->sprite_offset[0][0], a-s->quarter_sample);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2112 my = RSHIFT(s->sprite_offset[0][1], a-s->quarter_sample);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2113 s->mb_type[xy]= MB_TYPE_GMC | MB_TYPE_SKIPED;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2114 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2115 }else{
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2116 PRINT_MB_TYPE("S");
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2117 mx = 0;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2118 my = 0;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2119 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2120 mot_val[0 ]= mot_val[2 ]=
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2121 mot_val[0+stride]= mot_val[2+stride]= mx;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2122 mot_val[1 ]= mot_val[3 ]=
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2123 mot_val[1+stride]= mot_val[3+stride]= my;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2124
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2125 if(s->mbintra_table[xy])
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2126 ff_clean_intra_table_entries(s);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2127
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2128 continue;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2129 }
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
2130 cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2131 if (cbpc < 0){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2132 fprintf(stderr, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2133 return DECODING_DESYNC;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2134 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2135 if (cbpc > 20)
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2136 cbpc+=3;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2137 else if (cbpc == 20)
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2138 fprintf(stderr, "Stuffing !");
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2139 s->cbp_table[xy]= cbpc&(8+3); //8 is dquant
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2140
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2141 s->mb_intra = ((cbpc & 4) != 0);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2142
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2143 if(s->mb_intra){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2144 PRINT_MB_TYPE("I");
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2145 s->mbintra_table[xy]= 1;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2146 s->mb_type[xy]= MB_TYPE_INTRA;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2147 mot_val[0 ]= mot_val[2 ]=
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2148 mot_val[0+stride]= mot_val[2+stride]= 0;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2149 mot_val[1 ]= mot_val[3 ]=
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2150 mot_val[1+stride]= mot_val[3+stride]= 0;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2151 }else{
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2152 if(s->mbintra_table[xy])
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2153 ff_clean_intra_table_entries(s);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2154
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2155 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2156 s->mcsel= get_bits1(&s->gb);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2157 else s->mcsel= 0;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2158
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2159 if ((cbpc & 16) == 0) {
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2160 PRINT_MB_TYPE("P");
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2161 /* 16x16 motion prediction */
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2162 s->mb_type[xy]= MB_TYPE_INTER;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2163
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2164 h263_pred_motion(s, 0, &pred_x, &pred_y);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2165 if(!s->mcsel)
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2166 mx = h263_decode_motion(s, pred_x, s->f_code);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2167 else {
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2168 const int a= s->sprite_warping_accuracy;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2169 if(s->divx_version==500 && s->divx_build==413){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2170 mx = s->sprite_offset[0][0] / (1<<(a-s->quarter_sample));
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2171 }else{
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2172 mx = RSHIFT(s->sprite_offset[0][0], a-s->quarter_sample);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2173 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2174 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2175 if (mx >= 0xffff)
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2176 return DECODING_DESYNC;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2177
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2178 if(!s->mcsel)
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2179 my = h263_decode_motion(s, pred_y, s->f_code);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2180 else{
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2181 const int a= s->sprite_warping_accuracy;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2182 if(s->divx_version==500 && s->divx_build==413){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2183 my = s->sprite_offset[0][1] / (1<<(a-s->quarter_sample));
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2184 }else{
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2185 my = RSHIFT(s->sprite_offset[0][1], a-s->quarter_sample);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2186 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2187 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2188 if (my >= 0xffff)
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2189 return DECODING_DESYNC;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2190 mot_val[0 ]= mot_val[2 ] =
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2191 mot_val[0+stride]= mot_val[2+stride]= mx;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2192 mot_val[1 ]= mot_val[3 ]=
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2193 mot_val[1+stride]= mot_val[3+stride]= my;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2194 } else {
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2195 int i;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2196 PRINT_MB_TYPE("4");
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2197 s->mb_type[xy]= MB_TYPE_INTER4V;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2198 for(i=0;i<4;i++) {
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2199 INT16 *mot_val= h263_pred_motion(s, i, &pred_x, &pred_y);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2200 mx = h263_decode_motion(s, pred_x, s->f_code);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2201 if (mx >= 0xffff)
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2202 return DECODING_DESYNC;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2203
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2204 my = h263_decode_motion(s, pred_y, s->f_code);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2205 if (my >= 0xffff)
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2206 return DECODING_DESYNC;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2207 mot_val[0] = mx;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2208 mot_val[1] = my;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2209 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2210 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2211 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2212 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2213 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2214 s->mb_x= 0;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2215 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2216
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2217 if (s->pict_type==I_TYPE && get_bits(&s->gb, 19)!=DC_MARKER ) s->decoding_error= DECODING_DESYNC;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2218 else if(s->pict_type!=I_TYPE && get_bits(&s->gb, 17)!=MOTION_MARKER) s->decoding_error= DECODING_DESYNC;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2219 if(s->decoding_error== DECODING_DESYNC){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2220 fprintf(stderr, "marker missing after first partition at %d %d\n", s->mb_x, s->mb_y);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2221 return DECODING_DESYNC;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2222 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2223
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2224 /* decode second partition */
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2225 mb_num=0;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2226 s->mb_x= s->resync_mb_x;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2227 for(s->mb_y= s->resync_mb_y; mb_num < s->mb_num_left; s->mb_y++){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2228 init_block_index(s);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2229 for(; mb_num < s->mb_num_left && s->mb_x<s->mb_width; s->mb_x++){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2230 const int xy= s->mb_x + s->mb_y*s->mb_width;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2231
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2232 mb_num++;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2233 update_block_index(s);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2234
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2235 if(s->pict_type==I_TYPE){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2236 int ac_pred= get_bits1(&s->gb);
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
2237 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2238 if(cbpy<0){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2239 fprintf(stderr, "cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2240 return DECODING_AC_LOST;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2241 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2242
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2243 s->cbp_table[xy]|= cbpy<<2;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2244 s->pred_dir_table[xy]|= ac_pred<<7;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2245 }else{ /* P || S_TYPE */
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2246 if(s->mb_type[xy]&MB_TYPE_INTRA){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2247 int dir=0,i;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2248 int ac_pred = get_bits1(&s->gb);
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
2249 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2250
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2251 if(cbpy<0){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2252 fprintf(stderr, "I cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2253 return DECODING_ACDC_LOST;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2254 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2255
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2256 if(s->cbp_table[xy] & 8) {
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2257 s->qscale += quant_tab[get_bits(&s->gb, 2)];
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2258 if (s->qscale < 1)
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2259 s->qscale = 1;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2260 else if (s->qscale > 31)
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2261 s->qscale = 31;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2262 h263_dc_scale(s);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2263 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2264 s->qscale_table[xy]= s->qscale;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2265
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2266 for(i=0; i<6; i++){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2267 int dc_pred_dir;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2268 int dc= mpeg4_decode_dc(s, i, &dc_pred_dir);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2269 if(dc < 0){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2270 fprintf(stderr, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2271 return DECODING_ACDC_LOST;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2272 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2273 dir<<=1;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2274 if(dc_pred_dir) dir|=1;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2275 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2276 s->cbp_table[xy]&= 3; //remove dquant
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2277 s->cbp_table[xy]|= cbpy<<2;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2278 s->pred_dir_table[xy]= dir | (ac_pred<<7);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2279 }else if(s->mb_type[xy]&MB_TYPE_SKIPED){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2280 s->qscale_table[xy]= s->qscale;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2281 s->cbp_table[xy]= 0;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2282 }else{
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
2283 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2284
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2285 if(cbpy<0){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2286 fprintf(stderr, "P cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2287 return DECODING_ACDC_LOST;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2288 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2289
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2290 if(s->cbp_table[xy] & 8) {
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2291 //fprintf(stderr, "dquant\n");
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2292 s->qscale += quant_tab[get_bits(&s->gb, 2)];
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2293 if (s->qscale < 1)
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2294 s->qscale = 1;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2295 else if (s->qscale > 31)
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2296 s->qscale = 31;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2297 h263_dc_scale(s);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2298 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2299 s->qscale_table[xy]= s->qscale;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2300
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2301 s->cbp_table[xy]&= 3; //remove dquant
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2302 s->cbp_table[xy]|= (cbpy^0xf)<<2;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2303 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2304 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2305 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2306 s->mb_x= 0;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2307 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2308
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2309
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2310 return 0;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2311 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2312
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2313 static int mpeg4_decode_partitioned_mb(MpegEncContext *s,
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2314 DCTELEM block[6][64])
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2315 {
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2316 int cbp, mb_type;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2317 const int xy= s->mb_x + s->mb_y*s->mb_width;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2318
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2319 if(s->mb_x==s->resync_mb_x && s->mb_y==s->resync_mb_y){ //Note resync_mb_{x,y}==0 at the start
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2320 int i;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2321 int block_index_backup[6];
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2322 int qscale= s->qscale;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2323
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2324 for(i=0; i<6; i++) block_index_backup[i]= s->block_index[i];
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2325
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2326 s->decoding_error= ff_mpeg4_decode_partitions(s);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2327
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2328 for(i=0; i<6; i++) s->block_index[i]= block_index_backup[i];
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2329 s->first_slice_line=1;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2330 s->mb_x= s->resync_mb_x;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2331 s->mb_y= s->resync_mb_y;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2332 s->qscale= qscale;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2333 h263_dc_scale(s);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2334
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2335 if(s->decoding_error==DECODING_DESYNC) return -1;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2336 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2337
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2338 mb_type= s->mb_type[xy];
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2339 if(s->decoding_error)
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2340 cbp=0;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2341 else
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2342 cbp = s->cbp_table[xy];
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2343
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2344 if(s->decoding_error!=DECODING_ACDC_LOST && s->qscale_table[xy] != s->qscale){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2345 s->qscale= s->qscale_table[xy];
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2346 h263_dc_scale(s);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2347 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2348
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2349 if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2350 int i;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2351 for(i=0; i<4; i++){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2352 s->mv[0][i][0] = s->motion_val[ s->block_index[i] ][0];
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2353 s->mv[0][i][1] = s->motion_val[ s->block_index[i] ][1];
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2354 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2355 s->mb_intra = mb_type&MB_TYPE_INTRA;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2356
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2357 if (mb_type&MB_TYPE_SKIPED) {
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2358 /* skip mb */
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2359 for(i=0;i<6;i++)
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2360 s->block_last_index[i] = -1;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2361 s->mv_dir = MV_DIR_FORWARD;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2362 s->mv_type = MV_TYPE_16X16;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2363 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2364 s->mcsel=1;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2365 s->mb_skiped = 0;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2366 }else{
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2367 s->mcsel=0;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2368 s->mb_skiped = 1;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2369 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2370 return 0;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2371 }else if(s->mb_intra && s->decoding_error!=DECODING_ACDC_LOST){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2372 s->ac_pred = s->pred_dir_table[xy]>>7;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2373
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2374 /* decode each block */
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2375 for (i = 0; i < 6; i++) {
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
2376 int ret= mpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, 1);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2377 if(ret==DECODING_AC_LOST){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2378 fprintf(stderr, "texture corrupted at %d %d (trying to continue with mc/dc only)\n", s->mb_x, s->mb_y);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2379 s->decoding_error=DECODING_AC_LOST;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2380 cbp=0;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2381 }else if(ret==DECODING_ACDC_LOST){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2382 fprintf(stderr, "dc corrupted at %d %d (trying to continue with mc only)\n", s->mb_x, s->mb_y);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2383 s->decoding_error=DECODING_ACDC_LOST;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2384 break;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2385 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2386 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2387 }else if(!s->mb_intra){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2388 // s->mcsel= 0; //FIXME do we need to init that
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2389
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2390 s->mv_dir = MV_DIR_FORWARD;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2391 if (mb_type&MB_TYPE_INTER4V) {
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2392 s->mv_type = MV_TYPE_8X8;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2393 } else {
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2394 s->mv_type = MV_TYPE_16X16;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2395 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2396 if(s->decoding_error==0 && cbp){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2397 /* decode each block */
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2398 for (i = 0; i < 6; i++) {
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
2399 int ret= mpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, 0);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2400 if(ret==DECODING_AC_LOST){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2401 fprintf(stderr, "texture corrupted at %d %d (trying to continue with mc/dc only)\n", s->mb_x, s->mb_y);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2402 s->decoding_error=DECODING_AC_LOST;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2403 break;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2404 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2405 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2406 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2407 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2408 } else { /* I-Frame */
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2409 int i;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2410 s->mb_intra = 1;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2411 s->ac_pred = s->pred_dir_table[xy]>>7;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2412
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2413 /* decode each block */
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2414 for (i = 0; i < 6; i++) {
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
2415 int ret= mpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, 1);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2416 if(ret==DECODING_AC_LOST){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2417 fprintf(stderr, "texture corrupted at %d %d (trying to continue with dc only)\n", s->mb_x, s->mb_y);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2418 s->decoding_error=DECODING_AC_LOST;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2419 cbp=0;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2420 }else if(ret==DECODING_ACDC_LOST){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2421 fprintf(stderr, "dc corrupted at %d %d\n", s->mb_x, s->mb_y);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2422 return -1;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2423 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2424 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2425 }
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2426
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2427 return 0;
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2428 }
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2429
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2430
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2431 int h263_decode_mb(MpegEncContext *s,
986e461dc072 Initial revision
glantau
parents:
diff changeset
2432 DCTELEM block[6][64])
986e461dc072 Initial revision
glantau
parents:
diff changeset
2433 {
986e461dc072 Initial revision
glantau
parents:
diff changeset
2434 int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2435 INT16 *mot_val;
110
e00e5d93457c Added Juergen Keil fix on quant_tab[4] type.
pulento
parents: 79
diff changeset
2436 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
2437
523
c7e4c8b9a3c4 warning fix patch by atmos
michaelni
parents: 498
diff changeset
2438 if(s->mb_x==0) PRINT_MB_TYPE("\n");
359
df0736462b9f move ABS() to common.h
michaelni
parents: 358
diff changeset
2439
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2440 if(s->resync_marker){
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2441 if(s->resync_mb_x == s->mb_x && s->resync_mb_y+1 == s->mb_y){
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2442 s->first_slice_line=0;
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2443 }
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2444 }
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2445
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2446 if(s->data_partitioning && s->pict_type!=B_TYPE)
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2447 return mpeg4_decode_partitioned_mb(s, block);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2448
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
2449 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
2450 if (get_bits1(&s->gb)) {
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2451 /* skip mb */
986e461dc072 Initial revision
glantau
parents:
diff changeset
2452 s->mb_intra = 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2453 for(i=0;i<6;i++)
986e461dc072 Initial revision
glantau
parents:
diff changeset
2454 s->block_last_index[i] = -1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2455 s->mv_dir = MV_DIR_FORWARD;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2456 s->mv_type = MV_TYPE_16X16;
255
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
2457 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
2458 const int a= s->sprite_warping_accuracy;
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
2459 // int l = (1 << (s->f_code - 1)) * 32;
359
df0736462b9f move ABS() to common.h
michaelni
parents: 358
diff changeset
2460 PRINT_MB_TYPE("G");
255
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
2461 s->mcsel=1;
301
d7f71eb89558 divx5-gmc bug workaround
michaelni
parents: 295
diff changeset
2462 if(s->divx_version==500 && s->divx_build==413){
d7f71eb89558 divx5-gmc bug workaround
michaelni
parents: 295
diff changeset
2463 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
2464 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
2465 }else{
d7f71eb89558 divx5-gmc bug workaround
michaelni
parents: 295
diff changeset
2466 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
2467 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
2468 }
255
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
2469 /* if (s->mv[0][0][0] < -l) s->mv[0][0][0]= -l;
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
2470 else if (s->mv[0][0][0] >= l) s->mv[0][0][0]= l-1;
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
2471 if (s->mv[0][0][1] < -l) s->mv[0][0][1]= -l;
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
2472 else if (s->mv[0][0][1] >= l) s->mv[0][0][1]= l-1;*/
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
2473
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
2474 s->mb_skiped = 0;
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
2475 }else{
359
df0736462b9f move ABS() to common.h
michaelni
parents: 358
diff changeset
2476 PRINT_MB_TYPE("S");
255
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
2477 s->mcsel=0;
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
2478 s->mv[0][0][0] = 0;
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
2479 s->mv[0][0][1] = 0;
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
2480 s->mb_skiped = 1;
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
2481 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2482 return 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2483 }
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
2484 cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
144
cb5dabd00ba2 - Bug fix on inter MCBPC table for inter+q.
pulento
parents: 110
diff changeset
2485 //fprintf(stderr, "\tCBPC: %d", cbpc);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2486 if (cbpc < 0)
986e461dc072 Initial revision
glantau
parents:
diff changeset
2487 return -1;
161
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
2488 if (cbpc > 20)
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
2489 cbpc+=3;
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
2490 else if (cbpc == 20)
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
2491 fprintf(stderr, "Stuffing !");
144
cb5dabd00ba2 - Bug fix on inter MCBPC table for inter+q.
pulento
parents: 110
diff changeset
2492
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2493 dquant = cbpc & 8;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2494 s->mb_intra = ((cbpc & 4) != 0);
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2495 if (s->mb_intra) goto intra;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2496
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
2497 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
2498 s->mcsel= get_bits1(&s->gb);
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
2499 else s->mcsel= 0;
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
2500 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2501 cbp = (cbpc & 3) | ((cbpy ^ 0xf) << 2);
986e461dc072 Initial revision
glantau
parents:
diff changeset
2502 if (dquant) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
2503 s->qscale += quant_tab[get_bits(&s->gb, 2)];
986e461dc072 Initial revision
glantau
parents:
diff changeset
2504 if (s->qscale < 1)
986e461dc072 Initial revision
glantau
parents:
diff changeset
2505 s->qscale = 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2506 else if (s->qscale > 31)
986e461dc072 Initial revision
glantau
parents:
diff changeset
2507 s->qscale = 31;
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2508 h263_dc_scale(s);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2509 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
2510 s->mv_dir = MV_DIR_FORWARD;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2511 if ((cbpc & 16) == 0) {
359
df0736462b9f move ABS() to common.h
michaelni
parents: 358
diff changeset
2512 PRINT_MB_TYPE("P");
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2513 /* 16x16 motion prediction */
986e461dc072 Initial revision
glantau
parents:
diff changeset
2514 s->mv_type = MV_TYPE_16X16;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2515 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
2516 if (s->umvplus_dec)
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
2517 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
2518 else if(!s->mcsel)
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2519 mx = h263_decode_motion(s, pred_x, s->f_code);
255
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
2520 else {
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
2521 const int a= s->sprite_warping_accuracy;
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
2522 // int l = (1 << (s->f_code - 1)) * 32;
301
d7f71eb89558 divx5-gmc bug workaround
michaelni
parents: 295
diff changeset
2523 if(s->divx_version==500 && s->divx_build==413){
d7f71eb89558 divx5-gmc bug workaround
michaelni
parents: 295
diff changeset
2524 mx = s->sprite_offset[0][0] / (1<<(a-s->quarter_sample));
d7f71eb89558 divx5-gmc bug workaround
michaelni
parents: 295
diff changeset
2525 }else{
d7f71eb89558 divx5-gmc bug workaround
michaelni
parents: 295
diff changeset
2526 mx = RSHIFT(s->sprite_offset[0][0], a-s->quarter_sample);
d7f71eb89558 divx5-gmc bug workaround
michaelni
parents: 295
diff changeset
2527 }
d7f71eb89558 divx5-gmc bug workaround
michaelni
parents: 295
diff changeset
2528 // if (mx < -l) mx= -l, printf("C");
d7f71eb89558 divx5-gmc bug workaround
michaelni
parents: 295
diff changeset
2529 // else if (mx >= l) mx= l-1, printf("C");
255
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
2530 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2531 if (mx >= 0xffff)
986e461dc072 Initial revision
glantau
parents:
diff changeset
2532 return -1;
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
2533
79
82e579c37bc3 Moved some H.263+ variables to MpegEncContext to be thread-safe.
pulento
parents: 78
diff changeset
2534 if (s->umvplus_dec)
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
2535 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
2536 else if(!s->mcsel)
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2537 my = h263_decode_motion(s, pred_y, s->f_code);
255
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
2538 else{
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
2539 const int a= s->sprite_warping_accuracy;
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
2540 // int l = (1 << (s->f_code - 1)) * 32;
301
d7f71eb89558 divx5-gmc bug workaround
michaelni
parents: 295
diff changeset
2541 if(s->divx_version==500 && s->divx_build==413){
d7f71eb89558 divx5-gmc bug workaround
michaelni
parents: 295
diff changeset
2542 my = s->sprite_offset[0][1] / (1<<(a-s->quarter_sample));
d7f71eb89558 divx5-gmc bug workaround
michaelni
parents: 295
diff changeset
2543 }else{
d7f71eb89558 divx5-gmc bug workaround
michaelni
parents: 295
diff changeset
2544 my = RSHIFT(s->sprite_offset[0][1], a-s->quarter_sample);
d7f71eb89558 divx5-gmc bug workaround
michaelni
parents: 295
diff changeset
2545 }
d7f71eb89558 divx5-gmc bug workaround
michaelni
parents: 295
diff changeset
2546 // if (my < -l) my= -l, printf("C");
d7f71eb89558 divx5-gmc bug workaround
michaelni
parents: 295
diff changeset
2547 // else if (my >= l) my= l-1, printf("C");
255
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
2548 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2549 if (my >= 0xffff)
986e461dc072 Initial revision
glantau
parents:
diff changeset
2550 return -1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2551 s->mv[0][0][0] = mx;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2552 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
2553 /*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
2554 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
2555 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
2556 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
2557 skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
2558
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2559 } else {
359
df0736462b9f move ABS() to common.h
michaelni
parents: 358
diff changeset
2560 PRINT_MB_TYPE("4");
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2561 s->mv_type = MV_TYPE_8X8;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2562 for(i=0;i<4;i++) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
2563 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
2564 if (s->umvplus_dec)
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
2565 mx = h263p_decode_umotion(s, pred_x);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
2566 else
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2567 mx = h263_decode_motion(s, pred_x, s->f_code);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2568 if (mx >= 0xffff)
986e461dc072 Initial revision
glantau
parents:
diff changeset
2569 return -1;
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
2570
79
82e579c37bc3 Moved some H.263+ variables to MpegEncContext to be thread-safe.
pulento
parents: 78
diff changeset
2571 if (s->umvplus_dec)
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
2572 my = h263p_decode_umotion(s, pred_y);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
2573 else
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2574 my = h263_decode_motion(s, pred_y, s->f_code);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2575 if (my >= 0xffff)
986e461dc072 Initial revision
glantau
parents:
diff changeset
2576 return -1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2577 s->mv[0][i][0] = mx;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2578 s->mv[0][i][1] = my;
79
82e579c37bc3 Moved some H.263+ variables to MpegEncContext to be thread-safe.
pulento
parents: 78
diff changeset
2579 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
2580 skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2581 mot_val[0] = mx;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2582 mot_val[1] = my;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2583 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
2584 }
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2585 } else if(s->pict_type==B_TYPE) {
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2586 int modb1; // first bit of modb
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2587 int modb2; // second bit of modb
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2588 int mb_type;
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
2589 uint16_t time_pp;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
2590 uint16_t time_pb;
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2591 int xy;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2592
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2593 s->mb_intra = 0; //B-frames never contain intra blocks
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2594 s->mcsel=0; // ... true gmc blocks
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2595
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2596 if(s->mb_x==0){
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2597 s->last_mv[0][0][0]=
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2598 s->last_mv[0][0][1]=
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2599 s->last_mv[1][0][0]=
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2600 s->last_mv[1][0][1]= 0;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2601 }
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2602
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2603 /* if we skipped it in the future P Frame than skip it now too */
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2604 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
2605
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2606 if(s->mb_skiped){
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2607 /* skip mb */
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2608 for(i=0;i<6;i++)
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2609 s->block_last_index[i] = -1;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2610
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2611 s->mv_dir = MV_DIR_FORWARD;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2612 s->mv_type = MV_TYPE_16X16;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2613 s->mv[0][0][0] = 0;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2614 s->mv[0][0][1] = 0;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2615 s->mv[1][0][0] = 0;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2616 s->mv[1][0][1] = 0;
291
ab46ebfd419f b-frame decoding bugfix
michaelni
parents: 290
diff changeset
2617 //FIXME is this correct?
ab46ebfd419f b-frame decoding bugfix
michaelni
parents: 290
diff changeset
2618 /* s->last_mv[0][0][0]=
ab46ebfd419f b-frame decoding bugfix
michaelni
parents: 290
diff changeset
2619 s->last_mv[0][0][1]=0;*/
523
c7e4c8b9a3c4 warning fix patch by atmos
michaelni
parents: 498
diff changeset
2620 PRINT_MB_TYPE("s");
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2621 return 0;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2622 }
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2623
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2624 modb1= get_bits1(&s->gb);
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2625 if(modb1==0){
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2626 modb2= get_bits1(&s->gb);
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
2627 mb_type= get_vlc2(&s->gb, mb_type_b_vlc.table, MB_TYPE_B_VLC_BITS, 1);
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2628 if(modb2==0) cbp= get_bits(&s->gb, 6);
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2629 else cbp=0;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2630 if (mb_type && cbp) {
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2631 if(get_bits1(&s->gb)){
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2632 s->qscale +=get_bits1(&s->gb)*4 - 2;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2633 if (s->qscale < 1)
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2634 s->qscale = 1;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2635 else if (s->qscale > 31)
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2636 s->qscale = 31;
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2637 h263_dc_scale(s);
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2638 }
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2639 }
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2640 }else{
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2641 mb_type=4; //like 0 but no vectors coded
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2642 cbp=0;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2643 }
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2644 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
2645 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
2646 switch(mb_type)
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2647 {
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
2648 case 0: /* direct */
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2649 mx = h263_decode_motion(s, 0, 1);
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2650 my = h263_decode_motion(s, 0, 1);
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
2651 case 4: /* direct with mx=my=0 */
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2652 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
266
252444e5259b optimization
michaelni
parents: 265
diff changeset
2653 xy= s->block_index[0];
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
2654 time_pp= s->pp_time;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
2655 time_pb= time_pp - s->bp_time;
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2656 //if(time_pp>3000 )printf("%d %d ", time_pp, time_pb);
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2657 //FIXME avoid divides
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2658 s->mv[0][0][0] = s->motion_val[xy][0]*time_pb/time_pp + mx;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2659 s->mv[0][0][1] = s->motion_val[xy][1]*time_pb/time_pp + my;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2660 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
2661 : s->motion_val[xy][0]*(time_pb - time_pp)/time_pp + mx;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2662 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
2663 : s->motion_val[xy][1]*(time_pb - time_pp)/time_pp + my;
598
0c950f816d61 4mv + bframe decoding bugfix
michaelni
parents: 597
diff changeset
2664 if(s->non_b_mv4_table[xy]){
0c950f816d61 4mv + bframe decoding bugfix
michaelni
parents: 597
diff changeset
2665 int i;
0c950f816d61 4mv + bframe decoding bugfix
michaelni
parents: 597
diff changeset
2666 s->mv_type = MV_TYPE_8X8;
0c950f816d61 4mv + bframe decoding bugfix
michaelni
parents: 597
diff changeset
2667 for(i=1; i<4; i++){
0c950f816d61 4mv + bframe decoding bugfix
michaelni
parents: 597
diff changeset
2668 xy= s->block_index[i];
0c950f816d61 4mv + bframe decoding bugfix
michaelni
parents: 597
diff changeset
2669 s->mv[0][i][0] = s->motion_val[xy][0]*time_pb/time_pp + mx;
0c950f816d61 4mv + bframe decoding bugfix
michaelni
parents: 597
diff changeset
2670 s->mv[0][i][1] = s->motion_val[xy][1]*time_pb/time_pp + my;
0c950f816d61 4mv + bframe decoding bugfix
michaelni
parents: 597
diff changeset
2671 s->mv[1][i][0] = mx ? s->mv[0][i][0] - s->motion_val[xy][0]
0c950f816d61 4mv + bframe decoding bugfix
michaelni
parents: 597
diff changeset
2672 : s->motion_val[xy][0]*(time_pb - time_pp)/time_pp + mx;
0c950f816d61 4mv + bframe decoding bugfix
michaelni
parents: 597
diff changeset
2673 s->mv[1][i][1] = my ? s->mv[0][i][1] - s->motion_val[xy][1]
0c950f816d61 4mv + bframe decoding bugfix
michaelni
parents: 597
diff changeset
2674 : s->motion_val[xy][1]*(time_pb - time_pp)/time_pp + my;
0c950f816d61 4mv + bframe decoding bugfix
michaelni
parents: 597
diff changeset
2675 }
0c950f816d61 4mv + bframe decoding bugfix
michaelni
parents: 597
diff changeset
2676 PRINT_MB_TYPE("4");
0c950f816d61 4mv + bframe decoding bugfix
michaelni
parents: 597
diff changeset
2677 }else{
0c950f816d61 4mv + bframe decoding bugfix
michaelni
parents: 597
diff changeset
2678 PRINT_MB_TYPE(mb_type==4 ? "D" : "S");
0c950f816d61 4mv + bframe decoding bugfix
michaelni
parents: 597
diff changeset
2679 }
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2680 /* s->mv[0][0][0] =
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2681 s->mv[0][0][1] =
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2682 s->mv[1][0][0] =
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2683 s->mv[1][0][1] = 1000;*/
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2684 break;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2685 case 1:
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2686 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2687 mx = h263_decode_motion(s, s->last_mv[0][0][0], s->f_code);
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2688 my = h263_decode_motion(s, s->last_mv[0][0][1], s->f_code);
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2689 s->last_mv[0][0][0]= s->mv[0][0][0] = mx;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2690 s->last_mv[0][0][1]= s->mv[0][0][1] = my;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2691
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2692 mx = h263_decode_motion(s, s->last_mv[1][0][0], s->b_code);
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2693 my = h263_decode_motion(s, s->last_mv[1][0][1], s->b_code);
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2694 s->last_mv[1][0][0]= s->mv[1][0][0] = mx;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2695 s->last_mv[1][0][1]= s->mv[1][0][1] = my;
359
df0736462b9f move ABS() to common.h
michaelni
parents: 358
diff changeset
2696 PRINT_MB_TYPE("i");
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2697 break;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2698 case 2:
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2699 s->mv_dir = MV_DIR_BACKWARD;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2700 mx = h263_decode_motion(s, s->last_mv[1][0][0], s->b_code);
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2701 my = h263_decode_motion(s, s->last_mv[1][0][1], s->b_code);
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2702 s->last_mv[1][0][0]= s->mv[1][0][0] = mx;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2703 s->last_mv[1][0][1]= s->mv[1][0][1] = my;
359
df0736462b9f move ABS() to common.h
michaelni
parents: 358
diff changeset
2704 PRINT_MB_TYPE("B");
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2705 break;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2706 case 3:
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2707 s->mv_dir = MV_DIR_FORWARD;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2708 mx = h263_decode_motion(s, s->last_mv[0][0][0], s->f_code);
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2709 my = h263_decode_motion(s, s->last_mv[0][0][1], s->f_code);
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2710 s->last_mv[0][0][0]= s->mv[0][0][0] = mx;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2711 s->last_mv[0][0][1]= s->mv[0][0][1] = my;
359
df0736462b9f move ABS() to common.h
michaelni
parents: 358
diff changeset
2712 PRINT_MB_TYPE("F");
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2713 break;
364
6b6332e7008a segfault fix for b-frame encoding with height%16!=0
michaelni
parents: 360
diff changeset
2714 default:
6b6332e7008a segfault fix for b-frame encoding with height%16!=0
michaelni
parents: 360
diff changeset
2715 printf("illegal MB_type\n");
6b6332e7008a segfault fix for b-frame encoding with height%16!=0
michaelni
parents: 360
diff changeset
2716 return -1;
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2717 }
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2718 } else { /* I-Frame */
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
2719 cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 1);
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2720 if (cbpc < 0)
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2721 return -1;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2722 dquant = cbpc & 4;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2723 s->mb_intra = 1;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2724 intra:
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2725 s->ac_pred = 0;
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
2726 if (s->h263_pred || s->h263_aic) {
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
2727 s->ac_pred = get_bits1(&s->gb);
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
2728 if (s->ac_pred && s->h263_aic)
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
2729 s->h263_aic_dir = get_bits1(&s->gb);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2730 }
591
d3f374218030 fixing mpeg4 mpeg quantizers
michaelni
parents: 582
diff changeset
2731 PRINT_MB_TYPE(s->ac_pred ? "A" : "I");
d3f374218030 fixing mpeg4 mpeg quantizers
michaelni
parents: 582
diff changeset
2732
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
2733 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2734 if(cbpy<0) return -1;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2735 cbp = (cbpc & 3) | (cbpy << 2);
986e461dc072 Initial revision
glantau
parents:
diff changeset
2736 if (dquant) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
2737 s->qscale += quant_tab[get_bits(&s->gb, 2)];
986e461dc072 Initial revision
glantau
parents:
diff changeset
2738 if (s->qscale < 1)
986e461dc072 Initial revision
glantau
parents:
diff changeset
2739 s->qscale = 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2740 else if (s->qscale > 31)
986e461dc072 Initial revision
glantau
parents:
diff changeset
2741 s->qscale = 31;
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2742 h263_dc_scale(s);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2743 }
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
2744
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
2745 /* decode each block */
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
2746 if (s->h263_pred) {
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
2747 for (i = 0; i < 6; i++) {
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
2748 if (mpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, 1) < 0)
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
2749 return -1;
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
2750 }
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
2751 } else {
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
2752 for (i = 0; i < 6; i++) {
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
2753 if (h263_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1) < 0)
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
2754 return -1;
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
2755 }
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
2756 }
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
2757 return 0;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2758 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
2759
986e461dc072 Initial revision
glantau
parents:
diff changeset
2760 /* decode each block */
986e461dc072 Initial revision
glantau
parents:
diff changeset
2761 if (s->h263_pred) {
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
2762 for (i = 0; i < 6; i++) {
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
2763 if (mpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, 0) < 0)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2764 return -1;
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
2765 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2766 } else {
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
2767 for (i = 0; i < 6; i++) {
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
2768 if (h263_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1) < 0)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2769 return -1;
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
2770 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2771 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
2772 return 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2773 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
2774
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2775 static int h263_decode_motion(MpegEncContext * s, int pred, int f_code)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2776 {
986e461dc072 Initial revision
glantau
parents:
diff changeset
2777 int code, val, sign, shift, l, m;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2778
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
2779 code = get_vlc2(&s->gb, mv_vlc.table, MV_VLC_BITS, 2);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2780 if (code < 0)
986e461dc072 Initial revision
glantau
parents:
diff changeset
2781 return 0xffff;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2782
986e461dc072 Initial revision
glantau
parents:
diff changeset
2783 if (code == 0)
986e461dc072 Initial revision
glantau
parents:
diff changeset
2784 return pred;
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
2785 sign = get_bits1(&s->gb);
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2786 shift = f_code - 1;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2787 val = (code - 1) << shift;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2788 if (shift > 0)
986e461dc072 Initial revision
glantau
parents:
diff changeset
2789 val |= get_bits(&s->gb, shift);
986e461dc072 Initial revision
glantau
parents:
diff changeset
2790 val++;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2791 if (sign)
986e461dc072 Initial revision
glantau
parents:
diff changeset
2792 val = -val;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2793 val += pred;
475
6ccc48e4c41b run1 can be <0 bugfix (found by fabrice)
michaelni
parents: 469
diff changeset
2794
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2795 /* modulo decoding */
986e461dc072 Initial revision
glantau
parents:
diff changeset
2796 if (!s->h263_long_vectors) {
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2797 l = (1 << (f_code - 1)) * 32;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2798 m = 2 * l;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2799 if (val < -l) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
2800 val += m;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2801 } else if (val >= l) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
2802 val -= m;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2803 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
2804 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
2805 /* horrible h263 long vector mode */
986e461dc072 Initial revision
glantau
parents:
diff changeset
2806 if (pred < -31 && val < -63)
986e461dc072 Initial revision
glantau
parents:
diff changeset
2807 val += 64;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2808 if (pred > 32 && val > 63)
986e461dc072 Initial revision
glantau
parents:
diff changeset
2809 val -= 64;
154
f914f710b8d0 - Fixed a bug on H.263 MV prediction for MB on GOBs limits.
pulento
parents: 144
diff changeset
2810
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2811 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
2812 return val;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2813 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
2814
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
2815 /* Decodes RVLC of H.263+ UMV */
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
2816 static int h263p_decode_umotion(MpegEncContext * s, int pred)
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
2817 {
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
2818 int code = 0, sign;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
2819
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
2820 if (get_bits1(&s->gb)) /* Motion difference = 0 */
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
2821 return pred;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
2822
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
2823 code = 2 + get_bits1(&s->gb);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
2824
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
2825 while (get_bits1(&s->gb))
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
2826 {
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
2827 code <<= 1;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
2828 code += get_bits1(&s->gb);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
2829 }
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
2830 sign = code & 1;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
2831 code >>= 1;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
2832
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
2833 code = (sign) ? (pred - code) : (pred + code);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
2834 #ifdef DEBUG
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
2835 fprintf(stderr,"H.263+ UMV Motion = %d\n", code);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
2836 #endif
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
2837 return code;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
2838
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
2839 }
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
2840
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2841 static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
986e461dc072 Initial revision
glantau
parents:
diff changeset
2842 int n, int coded)
986e461dc072 Initial revision
glantau
parents:
diff changeset
2843 {
986e461dc072 Initial revision
glantau
parents:
diff changeset
2844 int code, level, i, j, last, run;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2845 RLTable *rl = &rl_inter;
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
2846 const UINT8 *scan_table;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2847
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
2848 scan_table = zigzag_direct;
249
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
2849 if (s->h263_aic && s->mb_intra) {
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
2850 rl = &rl_intra_aic;
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
2851 i = 0;
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
2852 if (s->ac_pred) {
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
2853 if (s->h263_aic_dir)
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
2854 scan_table = ff_alternate_vertical_scan; /* left */
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
2855 else
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
2856 scan_table = ff_alternate_horizontal_scan; /* top */
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
2857 }
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
2858 } else if (s->mb_intra) {
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
2859 /* DC coef */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2860 if (s->h263_rv10 && s->rv10_version == 3 && s->pict_type == I_TYPE) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
2861 int component, diff;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2862 component = (n <= 3 ? 0 : n - 4 + 1);
986e461dc072 Initial revision
glantau
parents:
diff changeset
2863 level = s->last_dc[component];
986e461dc072 Initial revision
glantau
parents:
diff changeset
2864 if (s->rv10_first_dc_coded[component]) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
2865 diff = rv_decode_dc(s, n);
986e461dc072 Initial revision
glantau
parents:
diff changeset
2866 if (diff == 0xffff)
986e461dc072 Initial revision
glantau
parents:
diff changeset
2867 return -1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2868 level += diff;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2869 level = level & 0xff; /* handle wrap round */
986e461dc072 Initial revision
glantau
parents:
diff changeset
2870 s->last_dc[component] = level;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2871 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
2872 s->rv10_first_dc_coded[component] = 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2873 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
2874 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
2875 level = get_bits(&s->gb, 8);
986e461dc072 Initial revision
glantau
parents:
diff changeset
2876 if (level == 255)
986e461dc072 Initial revision
glantau
parents:
diff changeset
2877 level = 128;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2878 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
2879 block[0] = level;
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
2880 i = 1;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2881 } else {
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
2882 i = 0;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2883 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
2884 if (!coded) {
249
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
2885 if (s->mb_intra && s->h263_aic)
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
2886 goto not_coded;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2887 s->block_last_index[n] = i - 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2888 return 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2889 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
2890
986e461dc072 Initial revision
glantau
parents:
diff changeset
2891 for(;;) {
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
2892 code = get_vlc2(&s->gb, rl->vlc.table, TEX_VLC_BITS, 2);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2893 if (code < 0)
986e461dc072 Initial revision
glantau
parents:
diff changeset
2894 return -1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2895 if (code == rl->n) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
2896 /* escape */
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
2897 last = get_bits1(&s->gb);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2898 run = get_bits(&s->gb, 6);
986e461dc072 Initial revision
glantau
parents:
diff changeset
2899 level = (INT8)get_bits(&s->gb, 8);
986e461dc072 Initial revision
glantau
parents:
diff changeset
2900 if (s->h263_rv10 && level == -128) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
2901 /* XXX: should patch encoder too */
986e461dc072 Initial revision
glantau
parents:
diff changeset
2902 level = get_bits(&s->gb, 12);
986e461dc072 Initial revision
glantau
parents:
diff changeset
2903 level = (level << 20) >> 20;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2904 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
2905 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
2906 run = rl->table_run[code];
986e461dc072 Initial revision
glantau
parents:
diff changeset
2907 level = rl->table_level[code];
986e461dc072 Initial revision
glantau
parents:
diff changeset
2908 last = code >= rl->last;
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
2909 if (get_bits1(&s->gb))
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2910 level = -level;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2911 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
2912 i += run;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2913 if (i >= 64)
986e461dc072 Initial revision
glantau
parents:
diff changeset
2914 return -1;
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
2915 j = scan_table[i];
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2916 block[j] = level;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2917 if (last)
986e461dc072 Initial revision
glantau
parents:
diff changeset
2918 break;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2919 i++;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2920 }
249
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
2921 not_coded:
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
2922 if (s->mb_intra && s->h263_aic) {
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
2923 h263_pred_acdc(s, block, n);
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
2924 i = 63;
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
2925 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2926 s->block_last_index[n] = i;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2927 return 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2928 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
2929
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2930 static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2931 {
986e461dc072 Initial revision
glantau
parents:
diff changeset
2932 int level, pred, code;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2933 UINT16 *dc_val;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2934
986e461dc072 Initial revision
glantau
parents:
diff changeset
2935 if (n < 4)
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
2936 code = get_vlc2(&s->gb, dc_lum.table, DC_VLC_BITS, 1);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2937 else
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
2938 code = get_vlc2(&s->gb, dc_chrom.table, DC_VLC_BITS, 1);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2939 if (code < 0 || code > 9 /* && s->nbit<9 */){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2940 fprintf(stderr, "illegal dc vlc\n");
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2941 return -1;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2942 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2943 if (code == 0) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
2944 level = 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2945 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
2946 level = get_bits(&s->gb, code);
986e461dc072 Initial revision
glantau
parents:
diff changeset
2947 if ((level >> (code - 1)) == 0) /* if MSB not set it is negative*/
986e461dc072 Initial revision
glantau
parents:
diff changeset
2948 level = - (level ^ ((1 << code) - 1));
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2949 if (code > 8){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2950 if(get_bits1(&s->gb)==0){ /* marker */
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2951 fprintf(stderr, "dc marker bit missing\n");
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2952 return -1;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2953 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2954 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2955 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
2956
498
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
2957 pred = ff_mpeg4_pred_dc(s, n, &dc_val, dir_ptr);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2958 level += pred;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2959 if (level < 0)
986e461dc072 Initial revision
glantau
parents:
diff changeset
2960 level = 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2961 if (n < 4) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
2962 *dc_val = level * s->y_dc_scale;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2963 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
2964 *dc_val = level * s->c_dc_scale;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2965 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
2966 return level;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2967 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
2968
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2969 /**
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2970 * decode a block
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2971 * returns 0 if everything went ok
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2972 * returns DECODING_AC_LOST if an error was detected during AC decoding
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2973 * returns DECODING_ACDC_LOST if an error was detected during DC decoding
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2974 */
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2975 static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
2976 int n, int coded, int intra)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2977 {
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
2978 int level, i, last, run;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2979 int dc_pred_dir;
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
2980 RLTable * rl;
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
2981 RL_VLC_ELEM * rl_vlc;
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
2982 const UINT8 * scan_table;
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
2983 int qmul, qadd;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2984
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
2985 if(intra) {
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2986 /* DC coef */
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2987 if(s->data_partitioning && s->pict_type!=B_TYPE){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2988 level = s->dc_val[0][ s->block_index[n] ];
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2989 if(n<4) level= (level + (s->y_dc_scale>>1))/s->y_dc_scale; //FIXME optimizs
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2990 else level= (level + (s->c_dc_scale>>1))/s->c_dc_scale;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2991 dc_pred_dir= (s->pred_dir_table[s->mb_x + s->mb_y*s->mb_width]<<n)&32;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2992 }else{
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2993 level = mpeg4_decode_dc(s, n, &dc_pred_dir);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2994 if (level < 0)
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2995 return DECODING_ACDC_LOST;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2996 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2997 block[0] = level;
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
2998 i = 0;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2999 if (!coded)
986e461dc072 Initial revision
glantau
parents:
diff changeset
3000 goto not_coded;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3001 rl = &rl_intra;
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3002 rl_vlc = rl_intra.rl_vlc[0];
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3003 if (s->ac_pred) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
3004 if (dc_pred_dir == 0)
986e461dc072 Initial revision
glantau
parents:
diff changeset
3005 scan_table = ff_alternate_vertical_scan; /* left */
986e461dc072 Initial revision
glantau
parents:
diff changeset
3006 else
986e461dc072 Initial revision
glantau
parents:
diff changeset
3007 scan_table = ff_alternate_horizontal_scan; /* top */
986e461dc072 Initial revision
glantau
parents:
diff changeset
3008 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
3009 scan_table = zigzag_direct;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3010 }
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3011 qmul=1;
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3012 qadd=0;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3013 } else {
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3014 i = -1;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3015 if (!coded) {
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3016 s->block_last_index[n] = i;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3017 return 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3018 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
3019 rl = &rl_inter;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3020 scan_table = zigzag_direct;
591
d3f374218030 fixing mpeg4 mpeg quantizers
michaelni
parents: 582
diff changeset
3021 if(s->mpeg_quant){
d3f374218030 fixing mpeg4 mpeg quantizers
michaelni
parents: 582
diff changeset
3022 qmul=1;
d3f374218030 fixing mpeg4 mpeg quantizers
michaelni
parents: 582
diff changeset
3023 qadd=0;
d3f374218030 fixing mpeg4 mpeg quantizers
michaelni
parents: 582
diff changeset
3024 rl_vlc = rl_inter.rl_vlc[0];
d3f374218030 fixing mpeg4 mpeg quantizers
michaelni
parents: 582
diff changeset
3025 }else{
d3f374218030 fixing mpeg4 mpeg quantizers
michaelni
parents: 582
diff changeset
3026 qmul = s->qscale << 1;
d3f374218030 fixing mpeg4 mpeg quantizers
michaelni
parents: 582
diff changeset
3027 qadd = (s->qscale - 1) | 1;
d3f374218030 fixing mpeg4 mpeg quantizers
michaelni
parents: 582
diff changeset
3028 rl_vlc = rl_inter.rl_vlc[s->qscale];
d3f374218030 fixing mpeg4 mpeg quantizers
michaelni
parents: 582
diff changeset
3029 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3030 }
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3031 {
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3032 OPEN_READER(re, &s->gb);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3033 for(;;) {
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3034 UPDATE_CACHE(re, &s->gb);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3035 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3036 if (level==0) {
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3037 int cache;
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3038 cache= GET_CACHE(re, &s->gb);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3039 /* escape */
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3040 if (cache&0x80000000) {
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3041 if (cache&0x40000000) {
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3042 /* third escape */
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3043 SKIP_CACHE(re, &s->gb, 2);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3044 last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3045 run= SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3046 SKIP_COUNTER(re, &s->gb, 2+1+6);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3047 UPDATE_CACHE(re, &s->gb);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3048
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3049 if(SHOW_UBITS(re, &s->gb, 1)==0){
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3050 fprintf(stderr, "1. marker bit missing in 3. esc\n");
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3051 return DECODING_AC_LOST;
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3052 }; SKIP_CACHE(re, &s->gb, 1);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3053
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3054 level= SHOW_SBITS(re, &s->gb, 12); SKIP_CACHE(re, &s->gb, 12);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3055
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3056 if(SHOW_UBITS(re, &s->gb, 1)==0){
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3057 fprintf(stderr, "2. marker bit missing in 3. esc\n");
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3058 return DECODING_AC_LOST;
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3059 }; LAST_SKIP_CACHE(re, &s->gb, 1);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3060
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3061 SKIP_COUNTER(re, &s->gb, 1+12+1);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3062
597
d5d0c11ea4cf fixing level overflow check for qp=1
michaelni
parents: 591
diff changeset
3063 if(level*s->qscale>1024 || level*s->qscale<-1024){
d5d0c11ea4cf fixing level overflow check for qp=1
michaelni
parents: 591
diff changeset
3064 fprintf(stderr, "|level| overflow in 3. esc, qp=%d\n", s->qscale);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3065 return DECODING_AC_LOST;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3066 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3067 #if 1
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3068 {
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3069 const int abs_level= ABS(level);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3070 if(abs_level<=MAX_LEVEL && run<=MAX_RUN && s->error_resilience>=0){
498
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
3071 const int run1= run - rl->max_run[last][abs_level] - 1;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3072 if(abs_level <= rl->max_level[last][run]){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3073 fprintf(stderr, "illegal 3. esc, vlc encoding possible\n");
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3074 return DECODING_AC_LOST;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3075 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3076 if(abs_level <= rl->max_level[last][run]*2){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3077 fprintf(stderr, "illegal 3. esc, esc 1 encoding possible\n");
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3078 return DECODING_AC_LOST;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3079 }
475
6ccc48e4c41b run1 can be <0 bugfix (found by fabrice)
michaelni
parents: 469
diff changeset
3080 if(run1 >= 0 && abs_level <= rl->max_level[last][run1]){
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3081 fprintf(stderr, "illegal 3. esc, esc 2 encoding possible\n");
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3082 return DECODING_AC_LOST;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3083 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3084 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3085 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3086 #endif
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3087 if (level>0) level= level * qmul + qadd;
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3088 else level= level * qmul - qadd;
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3089
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3090 i+= run + 1;
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3091 if(last) i+=192;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3092 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
3093 /* second escape */
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3094 #if MIN_CACHE_BITS < 20
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3095 LAST_SKIP_BITS(re, &s->gb, 2);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3096 UPDATE_CACHE(re, &s->gb);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3097 #else
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3098 SKIP_BITS(re, &s->gb, 2);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3099 #endif
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3100 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3101 i+= run + rl->max_run[run>>7][level/qmul] +1; //FIXME opt indexing
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3102 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3103 LAST_SKIP_BITS(re, &s->gb, 1);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3104 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
3105 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
3106 /* first escape */
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3107 #if MIN_CACHE_BITS < 19
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3108 LAST_SKIP_BITS(re, &s->gb, 1);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3109 UPDATE_CACHE(re, &s->gb);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3110 #else
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3111 SKIP_BITS(re, &s->gb, 1);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3112 #endif
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3113 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3114 i+= run;
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3115 level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//FIXME opt indexing
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3116 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3117 LAST_SKIP_BITS(re, &s->gb, 1);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3118 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
3119 } else {
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3120 i+= run;
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3121 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3122 LAST_SKIP_BITS(re, &s->gb, 1);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3123 }
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3124 if (i > 62){
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3125 i-= 192;
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3126 if(i&(~63)){
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3127 fprintf(stderr, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3128 return DECODING_AC_LOST;
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3129 }
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3130
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3131 block[scan_table[i]] = level;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3132 break;
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3133 }
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3134
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3135 block[scan_table[i]] = level;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3136 }
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3137 CLOSE_READER(re, &s->gb);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3138 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3139 not_coded:
986e461dc072 Initial revision
glantau
parents:
diff changeset
3140 if (s->mb_intra) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
3141 mpeg4_pred_ac(s, block, n, dc_pred_dir);
986e461dc072 Initial revision
glantau
parents:
diff changeset
3142 if (s->ac_pred) {
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3143 i = 63; /* XXX: not optimal */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3144 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
3145 }
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3146 s->block_last_index[n] = i;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3147 return 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3148 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
3149
986e461dc072 Initial revision
glantau
parents:
diff changeset
3150 /* most is hardcoded. should extend to handle all h263 streams */
986e461dc072 Initial revision
glantau
parents:
diff changeset
3151 int h263_decode_picture_header(MpegEncContext *s)
986e461dc072 Initial revision
glantau
parents:
diff changeset
3152 {
986e461dc072 Initial revision
glantau
parents:
diff changeset
3153 int format, width, height;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3154
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3155 /* picture start code */
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3156 if (get_bits(&s->gb, 22) != 0x20) {
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3157 fprintf(stderr, "Bad picture start code\n");
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3158 return -1;
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3159 }
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3160 /* temporal reference */
231
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
3161 s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3162
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3163 /* PTYPE starts here */
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3164 if (get_bits1(&s->gb) != 1) {
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3165 /* marker */
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3166 fprintf(stderr, "Bad marker\n");
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3167 return -1;
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3168 }
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3169 if (get_bits1(&s->gb) != 0) {
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3170 fprintf(stderr, "Bad H263 id\n");
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3171 return -1; /* h263 id */
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3172 }
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
3173 skip_bits1(&s->gb); /* split screen off */
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
3174 skip_bits1(&s->gb); /* camera off */
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
3175 skip_bits1(&s->gb); /* freeze picture release off */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3176
155
3c3449bce692 - Bug fix on MV prediction for MPEG4 caused by new H.263 GOB code.
pulento
parents: 154
diff changeset
3177 /* Reset GOB number */
154
f914f710b8d0 - Fixed a bug on H.263 MV prediction for MB on GOBs limits.
pulento
parents: 144
diff changeset
3178 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
3179
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3180 format = get_bits(&s->gb, 3);
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3181 /*
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3182 0 forbidden
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3183 1 sub-QCIF
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3184 10 QCIF
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3185 7 extended PTYPE (PLUSPTYPE)
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3186 */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3187
161
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3188 if (format != 7 && format != 6) {
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3189 s->h263_plus = 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3190 /* H.263v1 */
986e461dc072 Initial revision
glantau
parents:
diff changeset
3191 width = h263_format[format][0];
986e461dc072 Initial revision
glantau
parents:
diff changeset
3192 height = h263_format[format][1];
986e461dc072 Initial revision
glantau
parents:
diff changeset
3193 if (!width)
986e461dc072 Initial revision
glantau
parents:
diff changeset
3194 return -1;
161
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3195
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3196 s->width = width;
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3197 s->height = height;
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
3198 s->pict_type = I_TYPE + get_bits1(&s->gb);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3199
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
3200 s->unrestricted_mv = get_bits1(&s->gb);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3201 s->h263_long_vectors = s->unrestricted_mv;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3202
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3203 if (get_bits1(&s->gb) != 0) {
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3204 fprintf(stderr, "H263 SAC not supported\n");
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3205 return -1; /* SAC: off */
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3206 }
161
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3207 if (get_bits1(&s->gb) != 0) {
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3208 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
3209 }
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3210
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3211 if (get_bits1(&s->gb) != 0) {
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3212 fprintf(stderr, "H263 PB frame not supported\n");
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3213 return -1; /* not PB frame */
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3214 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3215 s->qscale = get_bits(&s->gb, 5);
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
3216 skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3217 } else {
161
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3218 int ufep;
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3219
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3220 /* H.263v2 */
161
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3221 s->h263_plus = 1;
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3222 ufep = get_bits(&s->gb, 3); /* Update Full Extended PTYPE */
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3223
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3224 /* ufep other than 0 and 1 are reserved */
161
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3225 if (ufep == 1) {
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3226 /* OPPTYPE */
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3227 format = get_bits(&s->gb, 3);
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3228 dprintf("ufep=1, format: %d\n", format);
161
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3229 skip_bits(&s->gb,1); /* Custom PCF */
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3230 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
3231 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
3232 if (get_bits1(&s->gb) != 0) {
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3233 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
3234 }
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
3235 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
3236 s->h263_aic = 1;
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
3237 }
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3238
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
3239 skip_bits(&s->gb, 7);
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3240 /* these are the 7 bits: (in order of appearence */
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3241 /* Deblocking Filter */
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3242 /* Slice Structured */
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3243 /* Reference Picture Selection */
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3244 /* Independent Segment Decoding */
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3245 /* Alternative Inter VLC */
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3246 /* Modified Quantization */
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3247 /* Prevent start code emulation */
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3248
161
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3249 skip_bits(&s->gb, 3); /* Reserved */
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3250 } else if (ufep != 0) {
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3251 fprintf(stderr, "Bad UFEP type (%d)\n", ufep);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3252 return -1;
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3253 }
161
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3254
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3255 /* MPPTYPE */
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3256 s->pict_type = get_bits(&s->gb, 3) + I_TYPE;
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3257 dprintf("pict_type: %d\n", s->pict_type);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3258 if (s->pict_type != I_TYPE &&
986e461dc072 Initial revision
glantau
parents:
diff changeset
3259 s->pict_type != P_TYPE)
986e461dc072 Initial revision
glantau
parents:
diff changeset
3260 return -1;
250
3449316664b5 - Bug fix on RTYPE (rounding type) not being honoured by H.263+ decoder.
pulento
parents: 249
diff changeset
3261 skip_bits(&s->gb, 2);
3449316664b5 - Bug fix on RTYPE (rounding type) not being honoured by H.263+ decoder.
pulento
parents: 249
diff changeset
3262 s->no_rounding = get_bits1(&s->gb);
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3263 dprintf("RTYPE: %d\n", s->no_rounding);
250
3449316664b5 - Bug fix on RTYPE (rounding type) not being honoured by H.263+ decoder.
pulento
parents: 249
diff changeset
3264 skip_bits(&s->gb, 4);
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3265
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3266 /* Get the picture dimensions */
161
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3267 if (ufep) {
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3268 if (format == 6) {
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3269 /* Custom Picture Format (CPFMT) */
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3270 s->aspect_ratio_info = get_bits(&s->gb, 4);
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3271 dprintf("aspect: %d\n", s->aspect_ratio_info);
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3272 /* aspect ratios:
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3273 0 - forbidden
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3274 1 - 1:1
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3275 2 - 12:11 (CIF 4:3)
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3276 3 - 10:11 (525-type 4:3)
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3277 4 - 16:11 (CIF 16:9)
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3278 5 - 40:33 (525-type 16:9)
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3279 6-14 - reserved
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3280 */
161
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3281 width = (get_bits(&s->gb, 9) + 1) * 4;
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3282 skip_bits1(&s->gb);
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3283 height = get_bits(&s->gb, 9) * 4;
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3284 dprintf("\nH.263+ Custom picture: %dx%d\n",width,height);
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3285 if (s->aspect_ratio_info == EXTENDED_PAR) {
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3286 /* aspected dimensions */
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3287 skip_bits(&s->gb, 8); /* width */
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3288 skip_bits(&s->gb, 8); /* height */
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3289 }
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3290 } else {
161
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3291 width = h263_format[format][0];
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3292 height = h263_format[format][1];
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3293 }
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3294 if ((width == 0) || (height == 0))
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3295 return -1;
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3296 s->width = width;
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3297 s->height = height;
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3298 if (s->umvplus_dec) {
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3299 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
3300 }
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3301 }
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3302
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3303 s->qscale = get_bits(&s->gb, 5);
986e461dc072 Initial revision
glantau
parents:
diff changeset
3304 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
3305 /* PEI */
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
3306 while (get_bits1(&s->gb) != 0) {
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
3307 skip_bits(&s->gb, 8);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3308 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
3309 s->f_code = 1;
498
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
3310
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
3311 if(s->h263_aic){
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
3312 s->y_dc_scale_table=
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
3313 s->c_dc_scale_table= h263_aic_dc_scale_table;
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
3314 }else{
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
3315 s->y_dc_scale_table=
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
3316 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
3317 }
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
3318
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3319 return 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3320 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
3321
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3322 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
3323 {
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3324 int i;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3325 int a= 2<<s->sprite_warping_accuracy;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3326 int rho= 3-s->sprite_warping_accuracy;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3327 int r=16/a;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3328 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
3329 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
3330 int sprite_ref[4][2];
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3331 int virtual_ref[2][2];
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3332 int w2, h2;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3333 int alpha=0, beta=0;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3334 int w= s->width;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3335 int h= s->height;
255
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
3336 //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
3337 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
3338 int length;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3339 int x=0, y=0;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3340
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3341 length= get_vlc(&s->gb, &sprite_trajectory);
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3342 if(length){
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3343 x= get_bits(&s->gb, length);
255
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
3344 //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
3345 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
3346 x = - (x ^ ((1 << length) - 1));
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3347 }
255
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
3348 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
3349
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3350 length= get_vlc(&s->gb, &sprite_trajectory);
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3351 if(length){
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3352 y=get_bits(&s->gb, length);
255
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
3353 //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
3354 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
3355 y = - (y ^ ((1 << length) - 1));
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3356 }
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3357 skip_bits1(&s->gb); /* marker bit */
255
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
3358 //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
3359 //if(i>0 && (x!=0 || y!=0)) printf("AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\n");
255
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
3360 //x=y=0;
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3361 d[i][0]= x;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3362 d[i][1]= y;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3363 }
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3364
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3365 while((1<<alpha)<w) alpha++;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3366 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
3367 w2= 1<<alpha;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3368 h2= 1<<beta;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3369
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3370 // Note, the 4th point isnt used for GMC
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3371 if(s->divx_version==500 && s->divx_build==413){
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3372 sprite_ref[0][0]= a*vop_ref[0][0] + d[0][0];
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3373 sprite_ref[0][1]= a*vop_ref[0][1] + d[0][1];
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3374 sprite_ref[1][0]= a*vop_ref[1][0] + d[0][0] + d[1][0];
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3375 sprite_ref[1][1]= a*vop_ref[1][1] + d[0][1] + d[1][1];
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3376 sprite_ref[2][0]= a*vop_ref[2][0] + d[0][0] + d[2][0];
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3377 sprite_ref[2][1]= a*vop_ref[2][1] + d[0][1] + d[2][1];
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3378 } else {
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3379 sprite_ref[0][0]= (a>>1)*(2*vop_ref[0][0] + d[0][0]);
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3380 sprite_ref[0][1]= (a>>1)*(2*vop_ref[0][1] + d[0][1]);
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3381 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
3382 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
3383 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
3384 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
3385 }
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3386 /* 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
3387 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
3388
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3389 // 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
3390 // 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
3391 // 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
3392 // 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
3393 virtual_ref[0][0]= 16*(vop_ref[0][0] + w2)
359
df0736462b9f move ABS() to common.h
michaelni
parents: 358
diff changeset
3394 + ROUNDED_DIV(((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
3395 virtual_ref[0][1]= 16*vop_ref[0][1]
359
df0736462b9f move ABS() to common.h
michaelni
parents: 358
diff changeset
3396 + ROUNDED_DIV(((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
3397 virtual_ref[1][0]= 16*vop_ref[0][0]
359
df0736462b9f move ABS() to common.h
michaelni
parents: 358
diff changeset
3398 + ROUNDED_DIV(((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
3399 virtual_ref[1][1]= 16*(vop_ref[0][1] + h2)
359
df0736462b9f move ABS() to common.h
michaelni
parents: 358
diff changeset
3400 + ROUNDED_DIV(((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
3401
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3402 switch(s->num_sprite_warping_points)
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3403 {
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3404 case 0:
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3405 s->sprite_offset[0][0]= 0;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3406 s->sprite_offset[0][1]= 0;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3407 s->sprite_offset[1][0]= 0;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3408 s->sprite_offset[1][1]= 0;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3409 s->sprite_delta[0][0][0]= a;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3410 s->sprite_delta[0][0][1]= 0;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3411 s->sprite_delta[0][1][0]= 0;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3412 s->sprite_delta[0][1][1]= a;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3413 s->sprite_delta[1][0][0]= a;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3414 s->sprite_delta[1][0][1]= 0;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3415 s->sprite_delta[1][1][0]= 0;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3416 s->sprite_delta[1][1][1]= a;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3417 s->sprite_shift[0][0]= 0;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3418 s->sprite_shift[0][1]= 0;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3419 s->sprite_shift[1][0]= 0;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3420 s->sprite_shift[1][1]= 0;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3421 break;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3422 case 1: //GMC only
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3423 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
3424 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
3425 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
3426 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
3427 s->sprite_delta[0][0][0]= a;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3428 s->sprite_delta[0][0][1]= 0;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3429 s->sprite_delta[0][1][0]= 0;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3430 s->sprite_delta[0][1][1]= a;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3431 s->sprite_delta[1][0][0]= a;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3432 s->sprite_delta[1][0][1]= 0;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3433 s->sprite_delta[1][1][0]= 0;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3434 s->sprite_delta[1][1][1]= a;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3435 s->sprite_shift[0][0]= 0;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3436 s->sprite_shift[0][1]= 0;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3437 s->sprite_shift[1][0]= 0;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3438 s->sprite_shift[1][1]= 0;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3439 break;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3440 case 2:
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3441 case 3: //FIXME
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3442 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
3443 + ((-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
3444 +( 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
3445 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
3446 + ((-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
3447 +(-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
3448 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
3449 +( 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
3450 +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
3451 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
3452 +(-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
3453 +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
3454 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
3455 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
3456 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
3457 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
3458 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
3459 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
3460 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
3461 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
3462 s->sprite_shift[0][0]= alpha+rho;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3463 s->sprite_shift[0][1]= alpha+rho;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3464 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
3465 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
3466 break;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3467 // case 3:
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3468 break;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3469 }
255
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
3470 /*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
3471 printf("%d %d\n", s->sprite_delta[0][0][1], 0);
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
3472 printf("%d %d\n", s->sprite_delta[0][1][0], 0);
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
3473 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
3474 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
3475 printf("%d %d\n", s->sprite_delta[1][0][1], 0);
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
3476 printf("%d %d\n", s->sprite_delta[1][1][0], 0);
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
3477 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
3478 /* try to simplify the situation */
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
3479 if( s->sprite_delta[0][0][0] == a<<s->sprite_shift[0][0]
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
3480 && s->sprite_delta[0][0][1] == 0
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
3481 && s->sprite_delta[0][1][0] == 0
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
3482 && s->sprite_delta[0][1][1] == a<<s->sprite_shift[0][1]
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
3483 && s->sprite_delta[1][0][0] == a<<s->sprite_shift[1][0]
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
3484 && s->sprite_delta[1][0][1] == 0
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
3485 && s->sprite_delta[1][1][0] == 0
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
3486 && s->sprite_delta[1][1][1] == a<<s->sprite_shift[1][1])
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
3487 {
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
3488 s->sprite_offset[0][0]>>=s->sprite_shift[0][0];
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
3489 s->sprite_offset[0][1]>>=s->sprite_shift[0][1];
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
3490 s->sprite_offset[1][0]>>=s->sprite_shift[1][0];
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
3491 s->sprite_offset[1][1]>>=s->sprite_shift[1][1];
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
3492 s->sprite_delta[0][0][0]= a;
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
3493 s->sprite_delta[0][0][1]= 0;
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
3494 s->sprite_delta[0][1][0]= 0;
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
3495 s->sprite_delta[0][1][1]= a;
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
3496 s->sprite_delta[1][0][0]= a;
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
3497 s->sprite_delta[1][0][1]= 0;
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
3498 s->sprite_delta[1][1][0]= 0;
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
3499 s->sprite_delta[1][1][1]= a;
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
3500 s->sprite_shift[0][0]= 0;
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
3501 s->sprite_shift[0][1]= 0;
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
3502 s->sprite_shift[1][0]= 0;
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
3503 s->sprite_shift[1][1]= 0;
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
3504 s->real_sprite_warping_points=1;
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
3505 }
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
3506 else
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
3507 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
3508
301
d7f71eb89558 divx5-gmc bug workaround
michaelni
parents: 295
diff changeset
3509 //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
3510 }
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3511
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3512 /* decode mpeg4 VOP header */
986e461dc072 Initial revision
glantau
parents:
diff changeset
3513 int mpeg4_decode_picture_header(MpegEncContext * s)
986e461dc072 Initial revision
glantau
parents:
diff changeset
3514 {
986e461dc072 Initial revision
glantau
parents:
diff changeset
3515 int time_incr, startcode, state, v;
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
3516 int time_increment;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3517
986e461dc072 Initial revision
glantau
parents:
diff changeset
3518 redo:
986e461dc072 Initial revision
glantau
parents:
diff changeset
3519 /* search next start code */
986e461dc072 Initial revision
glantau
parents:
diff changeset
3520 align_get_bits(&s->gb);
986e461dc072 Initial revision
glantau
parents:
diff changeset
3521 state = 0xff;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3522 for(;;) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
3523 v = get_bits(&s->gb, 8);
986e461dc072 Initial revision
glantau
parents:
diff changeset
3524 if (state == 0x000001) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
3525 state = ((state << 8) | v) & 0xffffff;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3526 startcode = state;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3527 break;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3528 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
3529 state = ((state << 8) | v) & 0xffffff;
278
michaelni
parents: 277
diff changeset
3530 if( get_bits_count(&s->gb) > s->gb.size*8-32){
333
8aa87f1dfc52 divx 5.01 support
michaelni
parents: 331
diff changeset
3531 if(s->gb.size>50){
8aa87f1dfc52 divx 5.01 support
michaelni
parents: 331
diff changeset
3532 printf("no VOP startcode found, frame size was=%d\n", s->gb.size);
8aa87f1dfc52 divx 5.01 support
michaelni
parents: 331
diff changeset
3533 return -1;
8aa87f1dfc52 divx 5.01 support
michaelni
parents: 331
diff changeset
3534 }else{
8aa87f1dfc52 divx 5.01 support
michaelni
parents: 331
diff changeset
3535 printf("frame skip\n");
8aa87f1dfc52 divx 5.01 support
michaelni
parents: 331
diff changeset
3536 return FRAME_SKIPED;
8aa87f1dfc52 divx 5.01 support
michaelni
parents: 331
diff changeset
3537 }
263
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
3538 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3539 }
253
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
3540 //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
3541 if (startcode == 0x120) { // Video Object Layer
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3542 int width, height, vo_ver_id;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3543
986e461dc072 Initial revision
glantau
parents:
diff changeset
3544 /* vol header */
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
3545 skip_bits(&s->gb, 1); /* random access */
336
c56b45669214 export delay info
michaelni
parents: 335
diff changeset
3546 s->vo_type= get_bits(&s->gb, 8);
63
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
3547 if (get_bits1(&s->gb) != 0) { /* is_ol_id */
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
3548 vo_ver_id = get_bits(&s->gb, 4); /* vo_ver_id */
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
3549 skip_bits(&s->gb, 3); /* vo_priority */
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
3550 } else {
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
3551 vo_ver_id = 1;
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
3552 }
341
bf26081c373c avcodec_flush_buffers()
michaelni
parents: 339
diff changeset
3553 //printf("vo type:%d\n",s->vo_type);
253
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
3554 s->aspect_ratio_info= get_bits(&s->gb, 4);
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3555 if(s->aspect_ratio_info == EXTENDED_PAR){
253
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
3556 skip_bits(&s->gb, 8); //par_width
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
3557 skip_bits(&s->gb, 8); // par_height
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
3558 }
281
1fc96b02142e mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents: 278
diff changeset
3559
365
fdeec2834c79 there are divx5? encoded files without a userdata section but with b-frames :(
michaelni
parents: 364
diff changeset
3560 if ((s->vol_control_parameters=get_bits1(&s->gb))) { /* vol control parameter */
336
c56b45669214 export delay info
michaelni
parents: 335
diff changeset
3561 int chroma_format= get_bits(&s->gb, 2);
c56b45669214 export delay info
michaelni
parents: 335
diff changeset
3562 if(chroma_format!=1){
c56b45669214 export delay info
michaelni
parents: 335
diff changeset
3563 printf("illegal chroma format\n");
c56b45669214 export delay info
michaelni
parents: 335
diff changeset
3564 }
c56b45669214 export delay info
michaelni
parents: 335
diff changeset
3565 s->low_delay= get_bits1(&s->gb);
c56b45669214 export delay info
michaelni
parents: 335
diff changeset
3566 if(get_bits1(&s->gb)){ /* vbv parameters */
c56b45669214 export delay info
michaelni
parents: 335
diff changeset
3567 printf("vbv parameters not supported\n");
c56b45669214 export delay info
michaelni
parents: 335
diff changeset
3568 return -1;
c56b45669214 export delay info
michaelni
parents: 335
diff changeset
3569 }
c56b45669214 export delay info
michaelni
parents: 335
diff changeset
3570 }else{
564
5329d156177a low_delay / has_b_frames fix
michaelni
parents: 563
diff changeset
3571 // set low delay flag only once so the smart? low delay detection wont be overriden
5329d156177a low_delay / has_b_frames fix
michaelni
parents: 563
diff changeset
3572 if(s->picture_number==0)
5329d156177a low_delay / has_b_frames fix
michaelni
parents: 563
diff changeset
3573 s->low_delay=0;
253
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
3574 }
336
c56b45669214 export delay info
michaelni
parents: 335
diff changeset
3575
63
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
3576 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
3577 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
3578 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
3579 printf("Gray shape not supported\n");
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
3580 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
3581 }
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
3582
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
3583 skip_bits1(&s->gb); /* marker */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3584
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3585 s->time_increment_resolution = get_bits(&s->gb, 16);
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3586 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
3587 if (s->time_increment_bits < 1)
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
3588 s->time_increment_bits = 1;
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
3589 skip_bits1(&s->gb); /* marker */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3590
63
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
3591 if (get_bits1(&s->gb) != 0) { /* fixed_vop_rate */
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
3592 skip_bits(&s->gb, s->time_increment_bits);
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
3593 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3594
253
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
3595 if (s->shape != BIN_ONLY_SHAPE) {
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
3596 if (s->shape == RECT_SHAPE) {
63
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
3597 skip_bits1(&s->gb); /* marker */
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
3598 width = get_bits(&s->gb, 13);
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
3599 skip_bits1(&s->gb); /* marker */
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
3600 height = get_bits(&s->gb, 13);
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
3601 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
3602 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
3603 s->width = width;
d0c186bcf075 use the width & height from the mpeg4 header ... in the case that its complete
michaelni
parents: 272
diff changeset
3604 s->height = height;
331
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
3605 // printf("width/height: %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
3606 }
63
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
3607 }
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
3608
264
28c5c62b1c4c support decoding (with mplayer) of 3 .mp4 files from mphq
michaelni
parents: 263
diff changeset
3609 if(get_bits1(&s->gb)) printf("interlaced not supported\n"); /* interlaced */
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3610 if(!get_bits1(&s->gb)) printf("OBMC not supported (very likely buggy encoder)\n"); /* OBMC Disable */
63
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
3611 if (vo_ver_id == 1) {
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
3612 s->vol_sprite_usage = get_bits1(&s->gb); /* vol_sprite_usage */
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
3613 } else {
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
3614 s->vol_sprite_usage = get_bits(&s->gb, 2); /* vol_sprite_usage */
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
3615 }
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3616 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
3617 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
3618 if(s->vol_sprite_usage==STATIC_SPRITE){
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
3619 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
3620 skip_bits1(&s->gb); /* marker */
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
3621 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
3622 skip_bits1(&s->gb); /* marker */
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
3623 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
3624 skip_bits1(&s->gb); /* marker */
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
3625 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
3626 skip_bits1(&s->gb); /* marker */
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
3627 }
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3628 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
3629 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
3630 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
3631 if(s->vol_sprite_usage==STATIC_SPRITE)
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
3632 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
3633 }
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
3634 // 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
3635
63
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
3636 if (get_bits1(&s->gb) == 1) { /* not_8_bit */
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
3637 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
3638 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
3639 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
3640 } else {
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
3641 s->quant_precision = 5;
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
3642 }
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
3643
253
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
3644 // FIXME a bunch of grayscale shape things
312
8cf5507e6ca5 mpeg4 mpeg quantizer support
michaelni
parents: 301
diff changeset
3645
591
d3f374218030 fixing mpeg4 mpeg quantizers
michaelni
parents: 582
diff changeset
3646 if((s->mpeg_quant=get_bits1(&s->gb))){ /* vol_quant_type */
312
8cf5507e6ca5 mpeg4 mpeg quantizer support
michaelni
parents: 301
diff changeset
3647 int i, j, v;
591
d3f374218030 fixing mpeg4 mpeg quantizers
michaelni
parents: 582
diff changeset
3648
312
8cf5507e6ca5 mpeg4 mpeg quantizer support
michaelni
parents: 301
diff changeset
3649 /* load default matrixes */
8cf5507e6ca5 mpeg4 mpeg quantizer support
michaelni
parents: 301
diff changeset
3650 for(i=0; i<64; i++){
8cf5507e6ca5 mpeg4 mpeg quantizer support
michaelni
parents: 301
diff changeset
3651 v= ff_mpeg4_default_intra_matrix[i];
8cf5507e6ca5 mpeg4 mpeg quantizer support
michaelni
parents: 301
diff changeset
3652 s->intra_matrix[i]= v;
8cf5507e6ca5 mpeg4 mpeg quantizer support
michaelni
parents: 301
diff changeset
3653 s->chroma_intra_matrix[i]= v;
8cf5507e6ca5 mpeg4 mpeg quantizer support
michaelni
parents: 301
diff changeset
3654
8cf5507e6ca5 mpeg4 mpeg quantizer support
michaelni
parents: 301
diff changeset
3655 v= ff_mpeg4_default_non_intra_matrix[i];
344
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
3656 s->inter_matrix[i]= v;
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
3657 s->chroma_inter_matrix[i]= v;
312
8cf5507e6ca5 mpeg4 mpeg quantizer support
michaelni
parents: 301
diff changeset
3658 }
8cf5507e6ca5 mpeg4 mpeg quantizer support
michaelni
parents: 301
diff changeset
3659
8cf5507e6ca5 mpeg4 mpeg quantizer support
michaelni
parents: 301
diff changeset
3660 /* load custom intra matrix */
8cf5507e6ca5 mpeg4 mpeg quantizer support
michaelni
parents: 301
diff changeset
3661 if(get_bits1(&s->gb)){
8cf5507e6ca5 mpeg4 mpeg quantizer support
michaelni
parents: 301
diff changeset
3662 for(i=0; i<64; i++){
8cf5507e6ca5 mpeg4 mpeg quantizer support
michaelni
parents: 301
diff changeset
3663 v= get_bits(&s->gb, 8);
8cf5507e6ca5 mpeg4 mpeg quantizer support
michaelni
parents: 301
diff changeset
3664 if(v==0) break;
8cf5507e6ca5 mpeg4 mpeg quantizer support
michaelni
parents: 301
diff changeset
3665
8cf5507e6ca5 mpeg4 mpeg quantizer support
michaelni
parents: 301
diff changeset
3666 j= zigzag_direct[i];
8cf5507e6ca5 mpeg4 mpeg quantizer support
michaelni
parents: 301
diff changeset
3667 s->intra_matrix[j]= v;
8cf5507e6ca5 mpeg4 mpeg quantizer support
michaelni
parents: 301
diff changeset
3668 s->chroma_intra_matrix[j]= v;
8cf5507e6ca5 mpeg4 mpeg quantizer support
michaelni
parents: 301
diff changeset
3669 }
8cf5507e6ca5 mpeg4 mpeg quantizer support
michaelni
parents: 301
diff changeset
3670 }
8cf5507e6ca5 mpeg4 mpeg quantizer support
michaelni
parents: 301
diff changeset
3671
8cf5507e6ca5 mpeg4 mpeg quantizer support
michaelni
parents: 301
diff changeset
3672 /* load custom non intra matrix */
8cf5507e6ca5 mpeg4 mpeg quantizer support
michaelni
parents: 301
diff changeset
3673 if(get_bits1(&s->gb)){
8cf5507e6ca5 mpeg4 mpeg quantizer support
michaelni
parents: 301
diff changeset
3674 for(i=0; i<64; i++){
8cf5507e6ca5 mpeg4 mpeg quantizer support
michaelni
parents: 301
diff changeset
3675 v= get_bits(&s->gb, 8);
8cf5507e6ca5 mpeg4 mpeg quantizer support
michaelni
parents: 301
diff changeset
3676 if(v==0) break;
8cf5507e6ca5 mpeg4 mpeg quantizer support
michaelni
parents: 301
diff changeset
3677
8cf5507e6ca5 mpeg4 mpeg quantizer support
michaelni
parents: 301
diff changeset
3678 j= zigzag_direct[i];
344
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
3679 s->inter_matrix[j]= v;
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
3680 s->chroma_inter_matrix[j]= v;
312
8cf5507e6ca5 mpeg4 mpeg quantizer support
michaelni
parents: 301
diff changeset
3681 }
8cf5507e6ca5 mpeg4 mpeg quantizer support
michaelni
parents: 301
diff changeset
3682
8cf5507e6ca5 mpeg4 mpeg quantizer support
michaelni
parents: 301
diff changeset
3683 /* replicate last value */
8cf5507e6ca5 mpeg4 mpeg quantizer support
michaelni
parents: 301
diff changeset
3684 for(; i<64; i++){
8cf5507e6ca5 mpeg4 mpeg quantizer support
michaelni
parents: 301
diff changeset
3685 j= zigzag_direct[i];
344
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
3686 s->inter_matrix[j]= v;
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
3687 s->chroma_inter_matrix[j]= v;
312
8cf5507e6ca5 mpeg4 mpeg quantizer support
michaelni
parents: 301
diff changeset
3688 }
8cf5507e6ca5 mpeg4 mpeg quantizer support
michaelni
parents: 301
diff changeset
3689 }
8cf5507e6ca5 mpeg4 mpeg quantizer support
michaelni
parents: 301
diff changeset
3690
8cf5507e6ca5 mpeg4 mpeg quantizer support
michaelni
parents: 301
diff changeset
3691 // FIXME a bunch of grayscale shape things
591
d3f374218030 fixing mpeg4 mpeg quantizers
michaelni
parents: 582
diff changeset
3692 }
312
8cf5507e6ca5 mpeg4 mpeg quantizer support
michaelni
parents: 301
diff changeset
3693
253
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
3694 if(vo_ver_id != 1)
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
3695 s->quarter_sample= get_bits1(&s->gb);
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
3696 else s->quarter_sample=0;
264
28c5c62b1c4c support decoding (with mplayer) of 3 .mp4 files from mphq
michaelni
parents: 263
diff changeset
3697
28c5c62b1c4c support decoding (with mplayer) of 3 .mp4 files from mphq
michaelni
parents: 263
diff changeset
3698 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
3699
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
3700 s->resync_marker= !get_bits1(&s->gb); /* resync_marker_disabled */
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
3701
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3702 s->data_partitioning= get_bits1(&s->gb);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3703 if(s->data_partitioning){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3704 s->rvlc= get_bits1(&s->gb);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3705 if(s->rvlc){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3706 printf("reversible vlc not supported\n");
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3707 }
253
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
3708 }
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
3709
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
3710 if(vo_ver_id != 1) {
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
3711 s->new_pred= get_bits1(&s->gb);
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
3712 if(s->new_pred){
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
3713 printf("new pred not supported\n");
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
3714 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
3715 skip_bits1(&s->gb); /* newpred segment type */
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
3716 }
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
3717 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
3718 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
3719 }
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
3720 else{
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
3721 s->new_pred=0;
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
3722 s->reduced_res_vop= 0;
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
3723 }
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
3724
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
3725 s->scalability= get_bits1(&s->gb);
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
3726 if(s->workaround_bugs==1) s->scalability=0;
253
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
3727 if (s->scalability) {
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
3728 int dummy= s->hierachy_type= get_bits1(&s->gb);
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
3729 int ref_layer_id= get_bits(&s->gb, 4);
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
3730 int ref_layer_sampling_dir= get_bits1(&s->gb);
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
3731 int h_sampling_factor_n= get_bits(&s->gb, 5);
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
3732 int h_sampling_factor_m= get_bits(&s->gb, 5);
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
3733 int v_sampling_factor_n= get_bits(&s->gb, 5);
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
3734 int v_sampling_factor_m= get_bits(&s->gb, 5);
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
3735 s->enhancement_type= get_bits1(&s->gb);
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
3736 // bin shape stuff FIXME
285
39b78867b71f dont return -1 if mpeg4 scalability ...
michaelni
parents: 283
diff changeset
3737 printf("scalability not supported\n");
63
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
3738 }
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
3739 }
253
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
3740 //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
3741 goto redo;
253
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
3742 } else if (startcode == 0x1b2) { //userdata
255
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
3743 char buf[256];
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
3744 int i;
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
3745 int e;
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
3746 int ver, build;
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
3747
253
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
3748 //printf("user Data %X\n", show_bits(&s->gb, 32));
255
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
3749 buf[0]= show_bits(&s->gb, 8);
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
3750 for(i=1; i<256; i++){
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
3751 buf[i]= show_bits(&s->gb, 16)&0xFF;
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
3752 if(buf[i]==0) break;
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
3753 skip_bits(&s->gb, 8);
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
3754 }
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
3755 buf[255]=0;
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
3756 e=sscanf(buf, "DivX%dBuild%d", &ver, &build);
333
8aa87f1dfc52 divx 5.01 support
michaelni
parents: 331
diff changeset
3757 if(e!=2)
8aa87f1dfc52 divx 5.01 support
michaelni
parents: 331
diff changeset
3758 e=sscanf(buf, "DivX%db%d", &ver, &build);
255
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
3759 if(e==2){
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
3760 s->divx_version= ver;
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
3761 s->divx_build= build;
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
3762 if(s->picture_number==0){
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
3763 printf("This file was encoded with DivX%d Build%d\n", ver, build);
333
8aa87f1dfc52 divx 5.01 support
michaelni
parents: 331
diff changeset
3764 if(ver==500 && build==413){
255
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
3765 printf("WARNING: this version of DivX is not MPEG4 compatible, trying to workaround these bugs...\n");
333
8aa87f1dfc52 divx 5.01 support
michaelni
parents: 331
diff changeset
3766 #if 0
255
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
3767 }else{
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
3768 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
3769 "using mpeg4 decoder, if it fails contact the developers (of ffmpeg)\n");
498
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
3770 #endif
255
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
3771 }
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
3772 }
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
3773 }
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
3774 //printf("User Data: %s\n", buf);
253
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
3775 goto redo;
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
3776 } else if (startcode != 0x1b6) { //VOP
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3777 goto redo;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3778 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
3779
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3780 s->pict_type = get_bits(&s->gb, 2) + I_TYPE; /* pict type: I = 0 , P = 1 */
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3781 //if(s->pict_type!=I_TYPE) return FRAME_SKIPED;
365
fdeec2834c79 there are divx5? encoded files without a userdata section but with b-frames :(
michaelni
parents: 364
diff changeset
3782 if(s->pict_type==B_TYPE && s->low_delay && s->vol_control_parameters==0){
fdeec2834c79 there are divx5? encoded files without a userdata section but with b-frames :(
michaelni
parents: 364
diff changeset
3783 printf("low_delay flag set, but shouldnt, clearing it\n");
fdeec2834c79 there are divx5? encoded files without a userdata section but with b-frames :(
michaelni
parents: 364
diff changeset
3784 s->low_delay=0;
fdeec2834c79 there are divx5? encoded files without a userdata section but with b-frames :(
michaelni
parents: 364
diff changeset
3785 }
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
3786 // printf("pic: %d, qpel:%d\n", s->pict_type, s->quarter_sample);
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3787 time_incr=0;
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
3788 while (get_bits1(&s->gb) != 0)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3789 time_incr++;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3790
264
28c5c62b1c4c support decoding (with mplayer) of 3 .mp4 files from mphq
michaelni
parents: 263
diff changeset
3791 check_marker(&s->gb, "before time_increment");
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
3792 time_increment= get_bits(&s->gb, s->time_increment_bits);
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
3793 //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
3794 if(s->pict_type!=B_TYPE){
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
3795 s->last_time_base= s->time_base;
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3796 s->time_base+= time_incr;
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
3797 s->time= s->time_base*s->time_increment_resolution + time_increment;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
3798 s->pp_time= s->time - s->last_non_b_time;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
3799 s->last_non_b_time= s->time;
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3800 }else{
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
3801 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
3802 s->bp_time= s->last_non_b_time - s->time;
335
e7e9d9901523 b-frame mpeg4 fix when seeking
michaelni
parents: 333
diff changeset
3803 if(s->pp_time <=s->bp_time){
e7e9d9901523 b-frame mpeg4 fix when seeking
michaelni
parents: 333
diff changeset
3804 // printf("messed up order, seeking?, skiping current b frame\n");
e7e9d9901523 b-frame mpeg4 fix when seeking
michaelni
parents: 333
diff changeset
3805 return FRAME_SKIPED;
e7e9d9901523 b-frame mpeg4 fix when seeking
michaelni
parents: 333
diff changeset
3806 }
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3807 }
264
28c5c62b1c4c support decoding (with mplayer) of 3 .mp4 files from mphq
michaelni
parents: 263
diff changeset
3808
28c5c62b1c4c support decoding (with mplayer) of 3 .mp4 files from mphq
michaelni
parents: 263
diff changeset
3809 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
3810 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
3811 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
3812 if(get_bits1(&s->gb)) break;
28c5c62b1c4c support decoding (with mplayer) of 3 .mp4 files from mphq
michaelni
parents: 263
diff changeset
3813 }
28c5c62b1c4c support decoding (with mplayer) of 3 .mp4 files from mphq
michaelni
parents: 263
diff changeset
3814 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
3815 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3816 /* vop coded */
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
3817 if (get_bits1(&s->gb) != 1)
63
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
3818 goto redo;
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3819 //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
3820 //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
3821 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
3822 || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE))) {
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3823 /* rounding type for motion estimation */
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
3824 s->no_rounding = get_bits1(&s->gb);
63
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
3825 } else {
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
3826 s->no_rounding = 0;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3827 }
253
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
3828 //FIXME reduced res stuff
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
3829
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
3830 if (s->shape != RECT_SHAPE) {
63
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
3831 if (s->vol_sprite_usage != 1 || s->pict_type != I_TYPE) {
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
3832 int width, height, hor_spat_ref, ver_spat_ref;
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
3833
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
3834 width = get_bits(&s->gb, 13);
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
3835 skip_bits1(&s->gb); /* marker */
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
3836 height = get_bits(&s->gb, 13);
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
3837 skip_bits1(&s->gb); /* marker */
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
3838 hor_spat_ref = get_bits(&s->gb, 13); /* hor_spat_ref */
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
3839 skip_bits1(&s->gb); /* marker */
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
3840 ver_spat_ref = get_bits(&s->gb, 13); /* ver_spat_ref */
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
3841 }
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
3842 skip_bits1(&s->gb); /* change_CR_disable */
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
3843
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
3844 if (get_bits1(&s->gb) != 0) {
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
3845 skip_bits(&s->gb, 8); /* constant_alpha_value */
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
3846 }
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
3847 }
253
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
3848 //FIXME complexity estimation stuff
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
3849
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
3850 if (s->shape != BIN_ONLY_SHAPE) {
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
3851 int t;
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
3852 t=get_bits(&s->gb, 3); /* intra dc VLC threshold */
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
3853 //printf("threshold %d\n", t);
253
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
3854 //FIXME interlaced specific bits
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
3855 }
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3856
253
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
3857 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
3858 if(s->num_sprite_warping_points){
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3859 mpeg4_decode_sprite_trajectory(s);
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3860 }
253
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
3861 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
3862 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
3863 }
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3864
253
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
3865 if (s->shape != BIN_ONLY_SHAPE) {
63
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
3866 /* note: we do not use quant_precision to avoid problem if no
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
3867 MPEG4 vol header as it is found on some old opendivx
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
3868 movies */
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
3869 s->qscale = get_bits(&s->gb, 5);
264
28c5c62b1c4c support decoding (with mplayer) of 3 .mp4 files from mphq
michaelni
parents: 263
diff changeset
3870 if(s->qscale==0){
28c5c62b1c4c support decoding (with mplayer) of 3 .mp4 files from mphq
michaelni
parents: 263
diff changeset
3871 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
3872 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
3873 }
63
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
3874
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
3875 if (s->pict_type != I_TYPE) {
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
3876 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
3877 if(s->f_code==0){
28c5c62b1c4c support decoding (with mplayer) of 3 .mp4 files from mphq
michaelni
parents: 263
diff changeset
3878 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
3879 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
3880 }
582
5132a4ee50cd different edge positions fixed with edge emu / dr1
michaelni
parents: 575
diff changeset
3881 }else
5132a4ee50cd different edge positions fixed with edge emu / dr1
michaelni
parents: 575
diff changeset
3882 s->f_code=1;
5132a4ee50cd different edge positions fixed with edge emu / dr1
michaelni
parents: 575
diff changeset
3883
253
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
3884 if (s->pict_type == B_TYPE) {
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
3885 s->b_code = get_bits(&s->gb, 3);
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3886 //printf("b-code %d\n", s->b_code);
582
5132a4ee50cd different edge positions fixed with edge emu / dr1
michaelni
parents: 575
diff changeset
3887 }else
5132a4ee50cd different edge positions fixed with edge emu / dr1
michaelni
parents: 575
diff changeset
3888 s->b_code=1;
5132a4ee50cd different edge positions fixed with edge emu / dr1
michaelni
parents: 575
diff changeset
3889
331
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
3890 //printf("quant:%d fcode:%d bcode:%d type:%d\n", s->qscale, s->f_code, s->b_code, s->pict_type);
253
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
3891 if(!s->scalability){
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
3892 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
3893 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
3894 }
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
3895 }else{
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
3896 if(s->enhancement_type){
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
3897 int load_backward_shape= get_bits1(&s->gb);
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
3898 if(load_backward_shape){
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
3899 printf("load backward shape isnt supported\n");
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
3900 }
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
3901 }
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
3902 skip_bits(&s->gb, 2); //ref_select_code
63
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
3903 }
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
3904 }
346
c2f789fe4945 detecting xvid/divx4/opendivx and set low_delay flag
michaelni
parents: 344
diff changeset
3905 /* detect buggy encoders which dont set the low_delay flag (divx4/xvid/opendivx)*/
c2f789fe4945 detecting xvid/divx4/opendivx and set low_delay flag
michaelni
parents: 344
diff changeset
3906 // note we cannot detect divx5 without b-frames easyly (allthough its buggy too)
365
fdeec2834c79 there are divx5? encoded files without a userdata section but with b-frames :(
michaelni
parents: 364
diff changeset
3907 if(s->vo_type==0 && s->vol_control_parameters==0 && s->divx_version==0 && s->picture_number==0){
fdeec2834c79 there are divx5? encoded files without a userdata section but with b-frames :(
michaelni
parents: 364
diff changeset
3908 printf("looks like this file was encoded with (divx4/(old)xvid/opendivx) -> forcing low_delay flag\n");
346
c2f789fe4945 detecting xvid/divx4/opendivx and set low_delay flag
michaelni
parents: 344
diff changeset
3909 s->low_delay=1;
c2f789fe4945 detecting xvid/divx4/opendivx and set low_delay flag
michaelni
parents: 344
diff changeset
3910 }
c2f789fe4945 detecting xvid/divx4/opendivx and set low_delay flag
michaelni
parents: 344
diff changeset
3911
255
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
3912 s->picture_number++; // better than pic number==0 allways ;)
333
8aa87f1dfc52 divx 5.01 support
michaelni
parents: 331
diff changeset
3913 //printf("done\n");
346
c2f789fe4945 detecting xvid/divx4/opendivx and set low_delay flag
michaelni
parents: 344
diff changeset
3914
498
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
3915 s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table; //FIXME add short header support
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
3916 s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
3917
582
5132a4ee50cd different edge positions fixed with edge emu / dr1
michaelni
parents: 575
diff changeset
3918 if(s->divx_version==0 || s->divx_version < 500){
5132a4ee50cd different edge positions fixed with edge emu / dr1
michaelni
parents: 575
diff changeset
3919 s->h_edge_pos= s->width;
5132a4ee50cd different edge positions fixed with edge emu / dr1
michaelni
parents: 575
diff changeset
3920 s->v_edge_pos= s->height;
5132a4ee50cd different edge positions fixed with edge emu / dr1
michaelni
parents: 575
diff changeset
3921 }
63
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
3922 return 0;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3923 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
3924
986e461dc072 Initial revision
glantau
parents:
diff changeset
3925 /* don't understand why they choose a different header ! */
986e461dc072 Initial revision
glantau
parents:
diff changeset
3926 int intel_h263_decode_picture_header(MpegEncContext *s)
986e461dc072 Initial revision
glantau
parents:
diff changeset
3927 {
986e461dc072 Initial revision
glantau
parents:
diff changeset
3928 int format;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3929
986e461dc072 Initial revision
glantau
parents:
diff changeset
3930 /* picture header */
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3931 if (get_bits(&s->gb, 22) != 0x20) {
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3932 fprintf(stderr, "Bad picture start code\n");
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3933 return -1;
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3934 }
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3935 s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3936
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3937 if (get_bits1(&s->gb) != 1) {
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3938 fprintf(stderr, "Bad marker\n");
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3939 return -1; /* marker */
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3940 }
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3941 if (get_bits1(&s->gb) != 0) {
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3942 fprintf(stderr, "Bad H263 id\n");
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3943 return -1; /* h263 id */
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3944 }
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
3945 skip_bits1(&s->gb); /* split screen off */
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
3946 skip_bits1(&s->gb); /* camera off */
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
3947 skip_bits1(&s->gb); /* freeze picture release off */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3948
986e461dc072 Initial revision
glantau
parents:
diff changeset
3949 format = get_bits(&s->gb, 3);
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3950 if (format != 7) {
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3951 fprintf(stderr, "Intel H263 free format not supported\n");
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3952 return -1;
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3953 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3954 s->h263_plus = 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3955
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
3956 s->pict_type = I_TYPE + get_bits1(&s->gb);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3957
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
3958 s->unrestricted_mv = get_bits1(&s->gb);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3959 s->h263_long_vectors = s->unrestricted_mv;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3960
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3961 if (get_bits1(&s->gb) != 0) {
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3962 fprintf(stderr, "SAC not supported\n");
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3963 return -1; /* SAC: off */
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3964 }
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3965 if (get_bits1(&s->gb) != 0) {
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3966 fprintf(stderr, "Advanced Prediction Mode not supported\n");
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3967 return -1; /* advanced prediction mode: off */
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3968 }
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3969 if (get_bits1(&s->gb) != 0) {
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3970 fprintf(stderr, "PB frame mode no supported\n");
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3971 return -1; /* PB frame mode */
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3972 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3973
986e461dc072 Initial revision
glantau
parents:
diff changeset
3974 /* skip unknown header garbage */
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
3975 skip_bits(&s->gb, 41);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3976
986e461dc072 Initial revision
glantau
parents:
diff changeset
3977 s->qscale = get_bits(&s->gb, 5);
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
3978 skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3979
986e461dc072 Initial revision
glantau
parents:
diff changeset
3980 /* PEI */
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
3981 while (get_bits1(&s->gb) != 0) {
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
3982 skip_bits(&s->gb, 8);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3983 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
3984 s->f_code = 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3985 return 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3986 }
144
cb5dabd00ba2 - Bug fix on inter MCBPC table for inter+q.
pulento
parents: 110
diff changeset
3987