annotate h263.c @ 818:15ec5cb57695 libavcodec

10l
author nickols_k
date Thu, 31 Oct 2002 18:22:15 +0000
parents 78accc54493b
children f5f2e162331c
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 *
656
e47fa3e3f2d5 statistics for forw & back p-MBs instead of just one counter for both
michaelni
parents: 654
diff changeset
21 * ac prediction encoding, b-frame support, error resilience, optimizations,
e47fa3e3f2d5 statistics for forw & back p-MBs instead of just one counter for both
michaelni
parents: 654
diff changeset
22 * qpel decoding, gmc decoding, interlaced decoding,
e47fa3e3f2d5 statistics for forw & back p-MBs instead of just one counter for both
michaelni
parents: 654
diff changeset
23 * by Michael Niedermayer <michaelni@gmx.at>
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
24 */
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
25
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
26 //#define DEBUG
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
27 #include "common.h"
986e461dc072 Initial revision
glantau
parents:
diff changeset
28 #include "dsputil.h"
986e461dc072 Initial revision
glantau
parents:
diff changeset
29 #include "avcodec.h"
986e461dc072 Initial revision
glantau
parents:
diff changeset
30 #include "mpegvideo.h"
986e461dc072 Initial revision
glantau
parents:
diff changeset
31 #include "h263data.h"
986e461dc072 Initial revision
glantau
parents:
diff changeset
32 #include "mpeg4data.h"
986e461dc072 Initial revision
glantau
parents:
diff changeset
33
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
34 //#undef NDEBUG
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
35 //#include <assert.h>
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
36
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
37 #if 1
523
c7e4c8b9a3c4 warning fix patch by atmos
michaelni
parents: 498
diff changeset
38 #define PRINT_MB_TYPE(a) {}
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
39 #else
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
40 #define PRINT_MB_TYPE(a) printf(a)
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
41 #endif
359
df0736462b9f move ABS() to common.h
michaelni
parents: 358
diff changeset
42
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
43 #define INTRA_MCBPC_VLC_BITS 6
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
44 #define INTER_MCBPC_VLC_BITS 6
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
45 #define CBPY_VLC_BITS 6
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
46 #define MV_VLC_BITS 9
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
47 #define DC_VLC_BITS 9
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
48 #define SPRITE_TRAJ_VLC_BITS 6
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
49 #define MB_TYPE_B_VLC_BITS 4
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
50 #define TEX_VLC_BITS 9
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
51
815
78accc54493b put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents: 770
diff changeset
52 #ifdef CONFIG_ENCODERS
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
53 static void h263_encode_block(MpegEncContext * s, DCTELEM * block,
986e461dc072 Initial revision
glantau
parents:
diff changeset
54 int n);
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
55 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
56 static void h263p_encode_umotion(MpegEncContext * s, int val);
648
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
57 static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block,
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
58 int n, int dc, UINT8 *scan_table,
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
59 PutBitContext *dc_pb, PutBitContext *ac_pb);
815
78accc54493b put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents: 770
diff changeset
60 #endif
78accc54493b put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents: 770
diff changeset
61
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
62 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
63 static int h263p_decode_umotion(MpegEncContext * s, int pred);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
64 static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
986e461dc072 Initial revision
glantau
parents:
diff changeset
65 int n, int coded);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
66 static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
67 static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
68 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
69 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
70 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
71 int dir);
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
72 static void mpeg4_decode_sprite_trajectory(MpegEncContext * s);
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
73 static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, UINT16 **dc_val_ptr, int *dir_ptr);
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
74
277
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
75 extern UINT32 inverse[256];
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
76
293
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
77 static UINT16 uni_DCtab_lum [512][2];
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
78 static UINT16 uni_DCtab_chrom[512][2];
815
78accc54493b put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents: 770
diff changeset
79
78accc54493b put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents: 770
diff changeset
80 #ifdef CONFIG_ENCODERS
78accc54493b put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents: 770
diff changeset
81 static UINT16 (*mv_penalty)[MAX_MV*2+1]= NULL;
78accc54493b put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents: 770
diff changeset
82 static UINT8 fcode_tab[MAX_MV*2+1];
78accc54493b put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents: 770
diff changeset
83 static UINT8 umv_fcode_tab[MAX_MV*2+1];
78accc54493b put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents: 770
diff changeset
84
648
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
85 static UINT32 uni_mpeg4_intra_rl_bits[64*64*2*2];
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
86 static UINT8 uni_mpeg4_intra_rl_len [64*64*2*2];
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
87 static UINT32 uni_mpeg4_inter_rl_bits[64*64*2*2];
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
88 static UINT8 uni_mpeg4_inter_rl_len [64*64*2*2];
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
89 #define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128 + (run)*256 + (level))
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
90 //#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run) + (level)*64)
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
91
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
92 /* mpeg4
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
93 inter
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
94 max level: 24/6
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
95 max run: 53/63
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
96
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
97 intra
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
98 max level: 53/16
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
99 max run: 29/41
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
100 */
815
78accc54493b put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents: 770
diff changeset
101 #endif
78accc54493b put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents: 770
diff changeset
102
293
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
103
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
104 int h263_get_picture_format(int width, int height)
986e461dc072 Initial revision
glantau
parents:
diff changeset
105 {
986e461dc072 Initial revision
glantau
parents:
diff changeset
106 int format;
986e461dc072 Initial revision
glantau
parents:
diff changeset
107
986e461dc072 Initial revision
glantau
parents:
diff changeset
108 if (width == 128 && height == 96)
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
109 format = 1;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
110 else if (width == 176 && height == 144)
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
111 format = 2;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
112 else if (width == 352 && height == 288)
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
113 format = 3;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
114 else if (width == 704 && height == 576)
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
115 format = 4;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
116 else if (width == 1408 && height == 1152)
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
117 format = 5;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
118 else
986e461dc072 Initial revision
glantau
parents:
diff changeset
119 format = 7;
986e461dc072 Initial revision
glantau
parents:
diff changeset
120 return format;
986e461dc072 Initial revision
glantau
parents:
diff changeset
121 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
122
986e461dc072 Initial revision
glantau
parents:
diff changeset
123 void h263_encode_picture_header(MpegEncContext * s, int picture_number)
986e461dc072 Initial revision
glantau
parents:
diff changeset
124 {
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
125 int format;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
126
986e461dc072 Initial revision
glantau
parents:
diff changeset
127 align_put_bits(&s->pb);
231
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
128
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
129 /* 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
130 s->ptr_lastgob = pbBufPtr(&s->pb);
231
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
131 s->gob_number = 0;
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
132
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
133 put_bits(&s->pb, 22, 0x20); /* PSC */
241
4bb6289eff93 avoid overflow of picturenumber*fps*10000
michaelni
parents: 234
diff changeset
134 put_bits(&s->pb, 8, (((INT64)s->picture_number * 30 * FRAME_RATE_BASE) /
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
135 s->frame_rate) & 0xff);
986e461dc072 Initial revision
glantau
parents:
diff changeset
136
986e461dc072 Initial revision
glantau
parents:
diff changeset
137 put_bits(&s->pb, 1, 1); /* marker */
986e461dc072 Initial revision
glantau
parents:
diff changeset
138 put_bits(&s->pb, 1, 0); /* h263 id */
986e461dc072 Initial revision
glantau
parents:
diff changeset
139 put_bits(&s->pb, 1, 0); /* split screen off */
986e461dc072 Initial revision
glantau
parents:
diff changeset
140 put_bits(&s->pb, 1, 0); /* camera off */
986e461dc072 Initial revision
glantau
parents:
diff changeset
141 put_bits(&s->pb, 1, 0); /* freeze picture release off */
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
142
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
143 format = h263_get_picture_format(s->width, s->height);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
144 if (!s->h263_plus) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
145 /* H.263v1 */
986e461dc072 Initial revision
glantau
parents:
diff changeset
146 put_bits(&s->pb, 3, format);
986e461dc072 Initial revision
glantau
parents:
diff changeset
147 put_bits(&s->pb, 1, (s->pict_type == P_TYPE));
986e461dc072 Initial revision
glantau
parents:
diff changeset
148 /* By now UMV IS DISABLED ON H.263v1, since the restrictions
986e461dc072 Initial revision
glantau
parents:
diff changeset
149 of H.263v1 UMV implies to check the predicted MV after
986e461dc072 Initial revision
glantau
parents:
diff changeset
150 calculation of the current MB to see if we're on the limits */
986e461dc072 Initial revision
glantau
parents:
diff changeset
151 put_bits(&s->pb, 1, 0); /* unrestricted motion vector: off */
986e461dc072 Initial revision
glantau
parents:
diff changeset
152 put_bits(&s->pb, 1, 0); /* SAC: off */
986e461dc072 Initial revision
glantau
parents:
diff changeset
153 put_bits(&s->pb, 1, 0); /* advanced prediction mode: off */
986e461dc072 Initial revision
glantau
parents:
diff changeset
154 put_bits(&s->pb, 1, 0); /* not PB frame */
986e461dc072 Initial revision
glantau
parents:
diff changeset
155 put_bits(&s->pb, 5, s->qscale);
986e461dc072 Initial revision
glantau
parents:
diff changeset
156 put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */
986e461dc072 Initial revision
glantau
parents:
diff changeset
157 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
158 /* H.263v2 */
986e461dc072 Initial revision
glantau
parents:
diff changeset
159 /* H.263 Plus PTYPE */
986e461dc072 Initial revision
glantau
parents:
diff changeset
160 put_bits(&s->pb, 3, 7);
986e461dc072 Initial revision
glantau
parents:
diff changeset
161 put_bits(&s->pb,3,1); /* Update Full Extended PTYPE */
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
162 if (format == 7)
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
163 put_bits(&s->pb,3,6); /* Custom Source Format */
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
164 else
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
165 put_bits(&s->pb, 3, format);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
166
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
167 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
168 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
169 put_bits(&s->pb, 1, s->umvplus); /* Unrestricted Motion Vector */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
170 put_bits(&s->pb,1,0); /* SAC: off */
986e461dc072 Initial revision
glantau
parents:
diff changeset
171 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
172 put_bits(&s->pb,1,s->h263_aic); /* Advanced Intra Coding */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
173 put_bits(&s->pb,1,0); /* Deblocking Filter: off */
986e461dc072 Initial revision
glantau
parents:
diff changeset
174 put_bits(&s->pb,1,0); /* Slice Structured: off */
986e461dc072 Initial revision
glantau
parents:
diff changeset
175 put_bits(&s->pb,1,0); /* Reference Picture Selection: off */
986e461dc072 Initial revision
glantau
parents:
diff changeset
176 put_bits(&s->pb,1,0); /* Independent Segment Decoding: off */
986e461dc072 Initial revision
glantau
parents:
diff changeset
177 put_bits(&s->pb,1,0); /* Alternative Inter VLC: off */
986e461dc072 Initial revision
glantau
parents:
diff changeset
178 put_bits(&s->pb,1,0); /* Modified Quantization: off */
986e461dc072 Initial revision
glantau
parents:
diff changeset
179 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
986e461dc072 Initial revision
glantau
parents:
diff changeset
180 put_bits(&s->pb,3,0); /* Reserved */
986e461dc072 Initial revision
glantau
parents:
diff changeset
181
986e461dc072 Initial revision
glantau
parents:
diff changeset
182 put_bits(&s->pb, 3, s->pict_type == P_TYPE);
986e461dc072 Initial revision
glantau
parents:
diff changeset
183
986e461dc072 Initial revision
glantau
parents:
diff changeset
184 put_bits(&s->pb,1,0); /* Reference Picture Resampling: off */
986e461dc072 Initial revision
glantau
parents:
diff changeset
185 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
186 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
187 s->no_rounding = 0;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
188 else
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
189 s->no_rounding ^= 1;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
190 put_bits(&s->pb,1,s->no_rounding); /* Rounding Type */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
191 put_bits(&s->pb,2,0); /* Reserved */
986e461dc072 Initial revision
glantau
parents:
diff changeset
192 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
986e461dc072 Initial revision
glantau
parents:
diff changeset
193
986e461dc072 Initial revision
glantau
parents:
diff changeset
194 /* This should be here if PLUSPTYPE */
986e461dc072 Initial revision
glantau
parents:
diff changeset
195 put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */
986e461dc072 Initial revision
glantau
parents:
diff changeset
196
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
197 if (format == 7) {
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
198 /* Custom Picture Format (CPFMT) */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
199
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
200 if (s->aspect_ratio_info)
669
b4bddbde44f3 aspect (ext. par too) support for h263 and mpeg4 (inc. build becouse of new vars)
al3x
parents: 667
diff changeset
201 put_bits(&s->pb,4,s->aspect_ratio_info);
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
202 else
669
b4bddbde44f3 aspect (ext. par too) support for h263 and mpeg4 (inc. build becouse of new vars)
al3x
parents: 667
diff changeset
203 put_bits(&s->pb,4,2); /* Aspect ratio: CIF 12:11 (4:3) picture */
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
204 put_bits(&s->pb,9,(s->width >> 2) - 1);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
205 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
206 put_bits(&s->pb,9,(s->height >> 2));
669
b4bddbde44f3 aspect (ext. par too) support for h263 and mpeg4 (inc. build becouse of new vars)
al3x
parents: 667
diff changeset
207 if (s->aspect_ratio_info == FF_ASPECT_EXTENDED)
b4bddbde44f3 aspect (ext. par too) support for h263 and mpeg4 (inc. build becouse of new vars)
al3x
parents: 667
diff changeset
208 {
b4bddbde44f3 aspect (ext. par too) support for h263 and mpeg4 (inc. build becouse of new vars)
al3x
parents: 667
diff changeset
209 put_bits(&s->pb, 8, s->aspected_width);
b4bddbde44f3 aspect (ext. par too) support for h263 and mpeg4 (inc. build becouse of new vars)
al3x
parents: 667
diff changeset
210 put_bits(&s->pb, 8, s->aspected_height);
b4bddbde44f3 aspect (ext. par too) support for h263 and mpeg4 (inc. build becouse of new vars)
al3x
parents: 667
diff changeset
211 }
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
212 }
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
213
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
214 /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
79
82e579c37bc3 Moved some H.263+ variables to MpegEncContext to be thread-safe.
pulento
parents: 78
diff changeset
215 if (s->umvplus)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
216 put_bits(&s->pb,1,1); /* Limited according tables of Annex D */
986e461dc072 Initial revision
glantau
parents:
diff changeset
217 put_bits(&s->pb, 5, s->qscale);
986e461dc072 Initial revision
glantau
parents:
diff changeset
218 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
219
986e461dc072 Initial revision
glantau
parents:
diff changeset
220 put_bits(&s->pb, 1, 0); /* no PEI */
498
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
221
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
222 if(s->h263_aic){
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
223 s->y_dc_scale_table=
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
224 s->c_dc_scale_table= h263_aic_dc_scale_table;
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
225 }else{
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
226 s->y_dc_scale_table=
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
227 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
228 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
229 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
230
766
8d36b35a7e6e slice encoding cleanup
michaelni
parents: 761
diff changeset
231 /**
8d36b35a7e6e slice encoding cleanup
michaelni
parents: 761
diff changeset
232 * Encodes a group of blocks header.
8d36b35a7e6e slice encoding cleanup
michaelni
parents: 761
diff changeset
233 */
162
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
234 int h263_encode_gob_header(MpegEncContext * s, int mb_line)
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
235 {
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
236 align_put_bits(&s->pb);
231
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
237 flush_put_bits(&s->pb);
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
238 /* Call the RTP callback to send the last GOB */
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
239 if (s->rtp_callback) {
766
8d36b35a7e6e slice encoding cleanup
michaelni
parents: 761
diff changeset
240 int pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;
231
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
241 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
242 }
162
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
243 put_bits(&s->pb, 17, 1); /* GBSC */
231
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
244 s->gob_number = mb_line / s->gob_index;
162
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
245 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
246 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
247 put_bits(&s->pb, 5, s->qscale); /* GQUANT */
231
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
248 //fprintf(stderr,"\nGOB: %2d size: %d", s->gob_number - 1, pdif);
766
8d36b35a7e6e slice encoding cleanup
michaelni
parents: 761
diff changeset
249 return 0;
162
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
250 }
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
251
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
252 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
253 {
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
254 int score0=0, score1=0;
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
255 int i, n;
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
256
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
257 for(n=0; n<6; n++){
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
258 INT16 *ac_val, *ac_val1;
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
259
266
252444e5259b optimization
michaelni
parents: 265
diff changeset
260 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
261 ac_val1= ac_val;
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
262 if(dir[n]){
692
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
263 const int xy= s->mb_x + s->mb_y*s->mb_width - s->mb_width;
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
264 /* top prediction */
266
252444e5259b optimization
michaelni
parents: 265
diff changeset
265 ac_val-= s->block_wrap[n]*16;
692
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
266 if(s->mb_y==0 || s->qscale == s->qscale_table[xy] || n==2 || n==3){
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
267 /* same qscale */
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
268 for(i=1; i<8; i++){
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
269 const int level= block[n][s->idct_permutation[i ]];
692
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
270 score0+= ABS(level);
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
271 score1+= ABS(level - ac_val[i+8]);
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
272 ac_val1[i ]= block[n][s->idct_permutation[i<<3]];
692
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
273 ac_val1[i+8]= level;
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
274 }
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
275 }else{
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
276 /* different qscale, we must rescale */
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
277 for(i=1; i<8; i++){
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
278 const int level= block[n][s->idct_permutation[i ]];
692
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
279 score0+= ABS(level);
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
280 score1+= ABS(level - ROUNDED_DIV(ac_val[i + 8]*s->qscale_table[xy], s->qscale));
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
281 ac_val1[i ]= block[n][s->idct_permutation[i<<3]];
692
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
282 ac_val1[i+8]= level;
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
283 }
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
284 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
285 }else{
692
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
286 const int xy= s->mb_x-1 + s->mb_y*s->mb_width;
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
287 /* left prediction */
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
288 ac_val-= 16;
692
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
289 if(s->mb_x==0 || s->qscale == s->qscale_table[xy] || n==1 || n==3){
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
290 /* same qscale */
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
291 for(i=1; i<8; i++){
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
292 const int level= block[n][s->idct_permutation[i<<3]];
692
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
293 score0+= ABS(level);
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
294 score1+= ABS(level - ac_val[i]);
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
295 ac_val1[i ]= level;
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
296 ac_val1[i+8]= block[n][s->idct_permutation[i ]];
692
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
297 }
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
298 }else{
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
299 /* different qscale, we must rescale */
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
300 for(i=1; i<8; i++){
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
301 const int level= block[n][s->idct_permutation[i<<3]];
692
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
302 score0+= ABS(level);
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
303 score1+= ABS(level - ROUNDED_DIV(ac_val[i]*s->qscale_table[xy], s->qscale));
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
304 ac_val1[i ]= level;
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
305 ac_val1[i+8]= block[n][s->idct_permutation[i ]];
692
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
306 }
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
307 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
308 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
309 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
310
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
311 return score0 > score1 ? 1 : 0;
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
312 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
313
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
314 /**
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
315 * modify qscale so that encoding is acually possible in h263 (limit difference to -2..2)
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
316 */
695
3525da287ee2 adaptive quantization for h263
michaelni
parents: 692
diff changeset
317 void ff_clean_h263_qscales(MpegEncContext *s){
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
318 int i;
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
319
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
320 for(i=1; i<s->mb_num; i++){
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
321 if(s->qscale_table[i] - s->qscale_table[i-1] >2)
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
322 s->qscale_table[i]= s->qscale_table[i-1]+2;
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
323 }
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
324 for(i=s->mb_num-2; i>=0; i--){
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
325 if(s->qscale_table[i] - s->qscale_table[i+1] >2)
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
326 s->qscale_table[i]= s->qscale_table[i+1]+2;
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
327 }
695
3525da287ee2 adaptive quantization for h263
michaelni
parents: 692
diff changeset
328 }
3525da287ee2 adaptive quantization for h263
michaelni
parents: 692
diff changeset
329
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
330 /**
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
331 * modify mb_type & qscale so that encoding is acually possible in mpeg4
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
332 */
695
3525da287ee2 adaptive quantization for h263
michaelni
parents: 692
diff changeset
333 void ff_clean_mpeg4_qscales(MpegEncContext *s){
3525da287ee2 adaptive quantization for h263
michaelni
parents: 692
diff changeset
334 int i;
3525da287ee2 adaptive quantization for h263
michaelni
parents: 692
diff changeset
335
3525da287ee2 adaptive quantization for h263
michaelni
parents: 692
diff changeset
336 ff_clean_h263_qscales(s);
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
337
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
338 for(i=1; i<s->mb_num; i++){
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
339 if(s->qscale_table[i] != s->qscale_table[i-1] && (s->mb_type[i]&MB_TYPE_INTER4V)){
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
340 s->mb_type[i]&= ~MB_TYPE_INTER4V;
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
341 s->mb_type[i]|= MB_TYPE_INTER;
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
342 }
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
343 }
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
344
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
345 if(s->pict_type== B_TYPE){
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
346 int odd=0;
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
347 /* ok, come on, this isnt funny anymore, theres more code for handling this mpeg4 mess than
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
348 for the actual adaptive quantization */
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
349
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
350 for(i=0; i<s->mb_num; i++){
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
351 odd += s->qscale_table[i]&1;
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
352 }
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
353
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
354 if(2*odd > s->mb_num) odd=1;
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
355 else odd=0;
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
356
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
357 for(i=0; i<s->mb_num; i++){
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
358 if((s->qscale_table[i]&1) != odd)
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
359 s->qscale_table[i]++;
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
360 if(s->qscale_table[i] > 31)
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
361 s->qscale_table[i]= 31;
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
362 }
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
363
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
364 for(i=1; i<s->mb_num; i++){
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
365 if(s->qscale_table[i] != s->qscale_table[i-1] && (s->mb_type[i]&MB_TYPE_DIRECT)){
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
366 s->mb_type[i]&= ~MB_TYPE_DIRECT;
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
367 s->mb_type[i]|= MB_TYPE_BIDIR;
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
368 }
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
369 }
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
370 }
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
371 }
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
372
815
78accc54493b put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents: 770
diff changeset
373 #ifdef CONFIG_ENCODERS
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
374 void mpeg4_encode_mb(MpegEncContext * s,
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
375 DCTELEM block[6][64],
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
376 int motion_x, int motion_y)
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
377 {
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
378 int cbpc, cbpy, i, pred_x, pred_y;
286
91f7c38f5f37 statistics for 2-pass encoding
michaelni
parents: 285
diff changeset
379 int bits;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
380 PutBitContext * const pb2 = s->data_partitioning ? &s->pb2 : &s->pb;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
381 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
382 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
383 const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1) && !s->data_partitioning ? 1 : 0;
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
384 const int dquant_code[5]= {1,0,9,2,3};
162
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
385
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
386 // 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
387 if (!s->mb_intra) {
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
388 /* compute cbp */
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
389 int cbp = 0;
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
390 for (i = 0; i < 6; i++) {
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
391 if (s->block_last_index[i] >= 0)
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
392 cbp |= 1 << (5 - i);
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
393 }
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
394
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
395 if(s->pict_type==B_TYPE){
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
396 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
397 int mb_type= mb_type_table[s->mv_dir];
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
398
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
399 if(s->mb_x==0){
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
400 s->last_mv[0][0][0]=
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
401 s->last_mv[0][0][1]=
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
402 s->last_mv[1][0][0]=
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
403 s->last_mv[1][0][1]= 0;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
404 }
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
405
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
406 assert(s->dquant>=-2 && s->dquant<=2);
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
407 assert((s->dquant&1)==0);
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
408 assert(mb_type>=0);
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
409
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
410 /* nothing to do if this MB was skiped in the next P Frame */
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
411 if(s->mbskip_table[s->mb_y * s->mb_width + s->mb_x]){ //FIXME avoid DCT & ...
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
412 s->skip_count++;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
413 s->mv[0][0][0]=
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
414 s->mv[0][0][1]=
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
415 s->mv[1][0][0]=
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
416 s->mv[1][0][1]= 0;
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
417 s->mv_dir= MV_DIR_FORWARD; //doesnt matter
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
418 s->qscale -= s->dquant;
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
419 return;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
420 }
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
421
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
422 if ((cbp | motion_x | motion_y | mb_type) ==0) {
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
423 /* direct MB with MV={0,0} */
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
424 assert(s->dquant==0);
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
425
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
426 put_bits(&s->pb, 1, 1); /* mb not coded modb1=1 */
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
427
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
428 if(interleaved_stats){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
429 s->misc_bits++;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
430 s->last_bits++;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
431 }
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
432 s->skip_count++;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
433 return;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
434 }
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
435 put_bits(&s->pb, 1, 0); /* mb coded modb1=0 */
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
436 put_bits(&s->pb, 1, cbp ? 0 : 1); /* modb2 */ //FIXME merge
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
437 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
438 if(cbp) put_bits(&s->pb, 6, cbp);
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
439
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
440 if(cbp && mb_type){
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
441 if(s->dquant)
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
442 put_bits(&s->pb, 2, (s->dquant>>2)+3);
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
443 else
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
444 put_bits(&s->pb, 1, 0);
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
445 }else
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
446 s->qscale -= s->dquant;
697
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
447
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
448 if(!s->progressive_sequence){
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
449 if(cbp)
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
450 put_bits(&s->pb, 1, s->interlaced_dct);
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
451 if(mb_type) // not diect mode
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
452 put_bits(&s->pb, 1, 0); // no interlaced ME yet
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
453 }
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
454
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
455 if(interleaved_stats){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
456 bits= get_bit_count(&s->pb);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
457 s->misc_bits+= bits - s->last_bits;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
458 s->last_bits=bits;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
459 }
295
6622b0fd036c mpeg4 4MV encoding
michaelni
parents: 294
diff changeset
460
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
461 switch(mb_type)
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
462 {
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
463 case 0: /* direct */
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
464 h263_encode_motion(s, motion_x, 1);
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
465 h263_encode_motion(s, motion_y, 1);
656
e47fa3e3f2d5 statistics for forw & back p-MBs instead of just one counter for both
michaelni
parents: 654
diff changeset
466 s->b_count++;
e47fa3e3f2d5 statistics for forw & back p-MBs instead of just one counter for both
michaelni
parents: 654
diff changeset
467 s->f_count++;
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
468 break;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
469 case 1: /* bidir */
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
470 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
471 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
472 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
473 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
474 s->last_mv[0][0][0]= s->mv[0][0][0];
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
475 s->last_mv[0][0][1]= s->mv[0][0][1];
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
476 s->last_mv[1][0][0]= s->mv[1][0][0];
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
477 s->last_mv[1][0][1]= s->mv[1][0][1];
656
e47fa3e3f2d5 statistics for forw & back p-MBs instead of just one counter for both
michaelni
parents: 654
diff changeset
478 s->b_count++;
e47fa3e3f2d5 statistics for forw & back p-MBs instead of just one counter for both
michaelni
parents: 654
diff changeset
479 s->f_count++;
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
480 break;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
481 case 2: /* backward */
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
482 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
483 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
484 s->last_mv[1][0][0]= motion_x;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
485 s->last_mv[1][0][1]= motion_y;
656
e47fa3e3f2d5 statistics for forw & back p-MBs instead of just one counter for both
michaelni
parents: 654
diff changeset
486 s->b_count++;
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
487 break;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
488 case 3: /* forward */
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
489 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
490 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
491 s->last_mv[0][0][0]= motion_x;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
492 s->last_mv[0][0][1]= motion_y;
656
e47fa3e3f2d5 statistics for forw & back p-MBs instead of just one counter for both
michaelni
parents: 654
diff changeset
493 s->f_count++;
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
494 break;
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
495 default:
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
496 printf("unknown mb type\n");
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
497 return;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
498 }
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
499
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
500 if(interleaved_stats){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
501 bits= get_bit_count(&s->pb);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
502 s->mv_bits+= bits - s->last_bits;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
503 s->last_bits=bits;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
504 }
295
6622b0fd036c mpeg4 4MV encoding
michaelni
parents: 294
diff changeset
505
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
506 /* encode each block */
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
507 for (i = 0; i < 6; i++) {
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
508 mpeg4_encode_block(s, block[i], i, 0, s->intra_scantable.permutated, NULL, &s->pb);
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
509 }
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
510
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
511 if(interleaved_stats){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
512 bits= get_bit_count(&s->pb);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
513 s->p_tex_bits+= bits - s->last_bits;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
514 s->last_bits=bits;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
515 }
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
516 }else{ /* s->pict_type==B_TYPE */
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
517 if ((cbp | motion_x | motion_y | s->dquant) == 0 && s->mv_type==MV_TYPE_16X16) {
331
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
518 /* 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
519 why didnt they just compress the skip-mb bits instead of reusing them ?! */
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
520 if(s->max_b_frames>0){
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
521 int i;
364
6b6332e7008a segfault fix for b-frame encoding with height%16!=0
michaelni
parents: 360
diff changeset
522 int x,y, offset;
6b6332e7008a segfault fix for b-frame encoding with height%16!=0
michaelni
parents: 360
diff changeset
523 uint8_t *p_pic;
6b6332e7008a segfault fix for b-frame encoding with height%16!=0
michaelni
parents: 360
diff changeset
524
6b6332e7008a segfault fix for b-frame encoding with height%16!=0
michaelni
parents: 360
diff changeset
525 x= s->mb_x*16;
6b6332e7008a segfault fix for b-frame encoding with height%16!=0
michaelni
parents: 360
diff changeset
526 y= s->mb_y*16;
6b6332e7008a segfault fix for b-frame encoding with height%16!=0
michaelni
parents: 360
diff changeset
527 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
528 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
529
6b6332e7008a segfault fix for b-frame encoding with height%16!=0
michaelni
parents: 360
diff changeset
530 offset= x + y*s->linesize;
6b6332e7008a segfault fix for b-frame encoding with height%16!=0
michaelni
parents: 360
diff changeset
531 p_pic= s->new_picture[0] + offset;
6b6332e7008a segfault fix for b-frame encoding with height%16!=0
michaelni
parents: 360
diff changeset
532
331
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
533 s->mb_skiped=1;
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
534 for(i=0; i<s->max_b_frames; i++){
339
b743a6bbab25 segfault fix
michaelni
parents: 336
diff changeset
535 uint8_t *b_pic;
b743a6bbab25 segfault fix
michaelni
parents: 336
diff changeset
536 int diff;
b743a6bbab25 segfault fix
michaelni
parents: 336
diff changeset
537
b743a6bbab25 segfault fix
michaelni
parents: 336
diff changeset
538 if(s->coded_order[i+1].pict_type!=B_TYPE) break;
b743a6bbab25 segfault fix
michaelni
parents: 336
diff changeset
539
b743a6bbab25 segfault fix
michaelni
parents: 336
diff changeset
540 b_pic= s->coded_order[i+1].picture[0] + offset;
b743a6bbab25 segfault fix
michaelni
parents: 336
diff changeset
541 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
542 if(diff>s->qscale*70){ //FIXME check that 70 is optimal
331
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
543 s->mb_skiped=0;
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
544 break;
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
545 }
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
546 }
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
547 }else
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
548 s->mb_skiped=1;
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
549
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
550 if(s->mb_skiped==1){
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
551 /* skip macroblock */
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
552 put_bits(&s->pb, 1, 1);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
553
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
554 if(interleaved_stats){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
555 s->misc_bits++;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
556 s->last_bits++;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
557 }
331
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
558 s->skip_count++;
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
559 return;
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
560 }
295
6622b0fd036c mpeg4 4MV encoding
michaelni
parents: 294
diff changeset
561 }
364
6b6332e7008a segfault fix for b-frame encoding with height%16!=0
michaelni
parents: 360
diff changeset
562
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
563 put_bits(&s->pb, 1, 0); /* mb coded */
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
564 if(s->mv_type==MV_TYPE_16X16){
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
565 cbpc = cbp & 3;
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
566 if(s->dquant) cbpc+= 8;
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
567 put_bits(&s->pb,
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
568 inter_MCBPC_bits[cbpc],
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
569 inter_MCBPC_code[cbpc]);
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
570
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
571 cbpy = cbp >> 2;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
572 cbpy ^= 0xf;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
573 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
574 if(s->dquant)
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
575 put_bits(pb2, 2, dquant_code[s->dquant+2]);
697
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
576
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
577 if(!s->progressive_sequence){
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
578 if(cbp)
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
579 put_bits(pb2, 1, s->interlaced_dct);
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
580 put_bits(pb2, 1, 0); // no interlaced ME yet
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
581 }
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
582
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
583 if(interleaved_stats){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
584 bits= get_bit_count(&s->pb);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
585 s->misc_bits+= bits - s->last_bits;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
586 s->last_bits=bits;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
587 }
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
588
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
589 /* motion vectors: 16x16 mode */
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
590 h263_pred_motion(s, 0, &pred_x, &pred_y);
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
591
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
592 h263_encode_motion(s, motion_x - pred_x, s->f_code);
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
593 h263_encode_motion(s, motion_y - pred_y, s->f_code);
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
594 }else{
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
595 cbpc = (cbp & 3)+16;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
596 put_bits(&s->pb,
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
597 inter_MCBPC_bits[cbpc],
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
598 inter_MCBPC_code[cbpc]);
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
599 cbpy = cbp >> 2;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
600 cbpy ^= 0xf;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
601 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
602
757
d031d1575ceb fixing interlaced dct with 4mv
michaelni
parents: 753
diff changeset
603 if(!s->progressive_sequence){
d031d1575ceb fixing interlaced dct with 4mv
michaelni
parents: 753
diff changeset
604 if(cbp)
d031d1575ceb fixing interlaced dct with 4mv
michaelni
parents: 753
diff changeset
605 put_bits(pb2, 1, s->interlaced_dct);
d031d1575ceb fixing interlaced dct with 4mv
michaelni
parents: 753
diff changeset
606 }
d031d1575ceb fixing interlaced dct with 4mv
michaelni
parents: 753
diff changeset
607
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
608 if(interleaved_stats){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
609 bits= get_bit_count(&s->pb);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
610 s->misc_bits+= bits - s->last_bits;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
611 s->last_bits=bits;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
612 }
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
613
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
614 for(i=0; i<4; i++){
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
615 /* motion vectors: 8x8 mode*/
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
616 h263_pred_motion(s, i, &pred_x, &pred_y);
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
617
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
618 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
619 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
620 }
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
621 }
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
622
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
623 if(interleaved_stats){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
624 bits= get_bit_count(&s->pb);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
625 s->mv_bits+= bits - s->last_bits;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
626 s->last_bits=bits;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
627 }
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
628
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
629 /* encode each block */
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
630 for (i = 0; i < 6; i++) {
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
631 mpeg4_encode_block(s, block[i], i, 0, s->intra_scantable.permutated, NULL, tex_pb);
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
632 }
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
633
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
634 if(interleaved_stats){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
635 bits= get_bit_count(&s->pb);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
636 s->p_tex_bits+= bits - s->last_bits;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
637 s->last_bits=bits;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
638 }
656
e47fa3e3f2d5 statistics for forw & back p-MBs instead of just one counter for both
michaelni
parents: 654
diff changeset
639 s->f_count++;
295
6622b0fd036c mpeg4 4MV encoding
michaelni
parents: 294
diff changeset
640 }
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
641 } else {
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
642 int cbp;
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
643 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
644 int dir[6]; //prediction direction
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
645 int zigzag_last_index[6];
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
646 UINT8 *scan_table[6];
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
647
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
648 for(i=0; i<6; i++){
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
649 const int level= block[i][0];
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
650 UINT16 *dc_ptr;
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
651
498
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
652 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
653 if (i < 4) {
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
654 *dc_ptr = level * s->y_dc_scale;
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
655 } else {
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
656 *dc_ptr = level * s->c_dc_scale;
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
657 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
658 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
659
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
660 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
661
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
662 if(s->ac_pred){
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
663 for(i=0; i<6; i++){
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
664 UINT8 *st;
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
665 int last_index;
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
666
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
667 mpeg4_inv_pred_ac(s, block[i], i, dir[i]);
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
668 if (dir[i]==0) st = s->intra_v_scantable.permutated; /* left */
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
669 else st = s->intra_h_scantable.permutated; /* top */
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
670
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
671 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
672 if(block[i][st[last_index]]) break;
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
673 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
674 s->block_last_index[i]= last_index;
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
675 scan_table[i]= st;
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
676 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
677 }else{
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
678 for(i=0; i<6; i++)
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
679 scan_table[i]= s->intra_scantable.permutated;
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
680 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
681
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
682 /* compute cbp */
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
683 cbp = 0;
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
684 for (i = 0; i < 6; i++) {
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
685 if (s->block_last_index[i] >= 1)
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
686 cbp |= 1 << (5 - i);
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
687 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
688
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
689 cbpc = cbp & 3;
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
690 if (s->pict_type == I_TYPE) {
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
691 if(s->dquant) cbpc+=4;
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
692 put_bits(&s->pb,
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
693 intra_MCBPC_bits[cbpc],
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
694 intra_MCBPC_code[cbpc]);
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
695 } else {
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
696 if(s->dquant) cbpc+=8;
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
697 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
698 put_bits(&s->pb,
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
699 inter_MCBPC_bits[cbpc + 4],
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
700 inter_MCBPC_code[cbpc + 4]);
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
701 }
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
702 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
703 cbpy = cbp >> 2;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
704 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
705 if(s->dquant)
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
706 put_bits(dc_pb, 2, dquant_code[s->dquant+2]);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
707
697
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
708 if(!s->progressive_sequence){
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
709 put_bits(dc_pb, 1, s->interlaced_dct);
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
710 }
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
711
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
712 if(interleaved_stats){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
713 bits= get_bit_count(&s->pb);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
714 s->misc_bits+= bits - s->last_bits;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
715 s->last_bits=bits;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
716 }
286
91f7c38f5f37 statistics for 2-pass encoding
michaelni
parents: 285
diff changeset
717
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
718 /* encode each block */
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
719 for (i = 0; i < 6; i++) {
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
720 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
721 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
722
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
723 if(interleaved_stats){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
724 bits= get_bit_count(&s->pb);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
725 s->i_tex_bits+= bits - s->last_bits;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
726 s->last_bits=bits;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
727 }
286
91f7c38f5f37 statistics for 2-pass encoding
michaelni
parents: 285
diff changeset
728 s->i_count++;
91f7c38f5f37 statistics for 2-pass encoding
michaelni
parents: 285
diff changeset
729
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
730 /* 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
731 if(s->ac_pred){
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
732 for(i=0; i<6; i++){
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
733 int j;
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
734 INT16 *ac_val;
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
735
266
252444e5259b optimization
michaelni
parents: 265
diff changeset
736 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
737
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
738 if(dir[i]){
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
739 for(j=1; j<8; j++)
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
740 block[i][s->idct_permutation[j ]]= ac_val[j+8];
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
741 }else{
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
742 for(j=1; j<8; j++)
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
743 block[i][s->idct_permutation[j<<3]]= ac_val[j ];
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
744 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
745 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
746 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
747 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
748 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
749 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
750
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
751 void h263_encode_mb(MpegEncContext * s,
986e461dc072 Initial revision
glantau
parents:
diff changeset
752 DCTELEM block[6][64],
986e461dc072 Initial revision
glantau
parents:
diff changeset
753 int motion_x, int motion_y)
986e461dc072 Initial revision
glantau
parents:
diff changeset
754 {
986e461dc072 Initial revision
glantau
parents:
diff changeset
755 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
756 INT16 pred_dc;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
757 INT16 rec_intradc[6];
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
758 UINT16 *dc_ptr[6];
695
3525da287ee2 adaptive quantization for h263
michaelni
parents: 692
diff changeset
759 const int dquant_code[5]= {1,0,9,2,3};
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
760
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
761 //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
762 if (!s->mb_intra) {
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
763 /* compute cbp */
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
764 cbp = 0;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
765 for (i = 0; i < 6; i++) {
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
766 if (s->block_last_index[i] >= 0)
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
767 cbp |= 1 << (5 - i);
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
768 }
695
3525da287ee2 adaptive quantization for h263
michaelni
parents: 692
diff changeset
769 if ((cbp | motion_x | motion_y | s->dquant) == 0) {
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
770 /* skip macroblock */
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
771 put_bits(&s->pb, 1, 1);
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
772 return;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
773 }
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
774 put_bits(&s->pb, 1, 0); /* mb coded */
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
775 cbpc = cbp & 3;
695
3525da287ee2 adaptive quantization for h263
michaelni
parents: 692
diff changeset
776 if(s->dquant) cbpc+= 8;
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
777 put_bits(&s->pb,
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
778 inter_MCBPC_bits[cbpc],
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
779 inter_MCBPC_code[cbpc]);
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
780 cbpy = cbp >> 2;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
781 cbpy ^= 0xf;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
782 put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
695
3525da287ee2 adaptive quantization for h263
michaelni
parents: 692
diff changeset
783 if(s->dquant)
3525da287ee2 adaptive quantization for h263
michaelni
parents: 692
diff changeset
784 put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
785
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
786 /* motion vectors: 16x16 mode only now */
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
787 h263_pred_motion(s, 0, &pred_x, &pred_y);
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
788
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
789 if (!s->umvplus) {
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
790 h263_encode_motion(s, motion_x - pred_x, s->f_code);
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
791 h263_encode_motion(s, motion_y - pred_y, s->f_code);
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
792 }
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
793 else {
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
794 h263p_encode_umotion(s, motion_x - pred_x);
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
795 h263p_encode_umotion(s, motion_y - pred_y);
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
796 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
797 /* To prevent Start Code emulation */
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
798 put_bits(&s->pb,1,1);
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
799 }
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
800 } else {
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
801 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
802
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
803 cbp = 0;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
804 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
805 /* Predict DC */
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
806 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
807 INT16 level = block[i][0];
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
808
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
809 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
810 level -= pred_dc;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
811 /* Quant */
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
812 if (level < 0)
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
813 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
814 else
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
815 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
816
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
817 /* AIC can change CBP */
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
818 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
819 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
820 else if (level < -127)
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
821 level = -127;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
822 else if (level > 127)
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
823 level = 127;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
824
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
825 block[i][0] = level;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
826 /* Reconstruction */
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
827 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
828 /* Oddify */
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
829 rec_intradc[i] |= 1;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
830 //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
831 // rec_intradc[i]++;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
832 /* Clipping */
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
833 if (rec_intradc[i] < 0)
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
834 rec_intradc[i] = 0;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
835 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
836 rec_intradc[i] = 2047;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
837
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
838 /* Update AC/DC tables */
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
839 *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
840 }
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
841 /* compute cbp */
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
842 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
843 cbp |= 1 << (5 - i);
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
844 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
845
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
846 cbpc = cbp & 3;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
847 if (s->pict_type == I_TYPE) {
695
3525da287ee2 adaptive quantization for h263
michaelni
parents: 692
diff changeset
848 if(s->dquant) cbpc+=4;
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
849 put_bits(&s->pb,
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
850 intra_MCBPC_bits[cbpc],
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
851 intra_MCBPC_code[cbpc]);
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
852 } else {
695
3525da287ee2 adaptive quantization for h263
michaelni
parents: 692
diff changeset
853 if(s->dquant) cbpc+=8;
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
854 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
855 put_bits(&s->pb,
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
856 inter_MCBPC_bits[cbpc + 4],
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
857 inter_MCBPC_code[cbpc + 4]);
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
858 }
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
859 if (s->h263_aic) {
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
860 /* 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
861 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
862 }
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
863 cbpy = cbp >> 2;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
864 put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
695
3525da287ee2 adaptive quantization for h263
michaelni
parents: 692
diff changeset
865 if(s->dquant)
3525da287ee2 adaptive quantization for h263
michaelni
parents: 692
diff changeset
866 put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
867 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
868
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
869 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
870 /* encode each block */
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 293
diff changeset
871 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
872
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
873 /* Update INTRADC for decoding */
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
874 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
875 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
876
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
877 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
878 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
879 }
815
78accc54493b put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents: 770
diff changeset
880 #endif
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
881
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
882 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
883 {
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
884 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
885 INT16 *dc_val, *ac_val;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
886
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
887 /* find prediction */
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
888 if (n < 4) {
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
889 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
890 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
891 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
892 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
893 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
894 scale = s->y_dc_scale;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
895 } else {
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
896 x = s->mb_x + 1;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
897 y = s->mb_y + 1;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
898 wrap = s->mb_width + 2;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
899 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
900 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
901 scale = s->c_dc_scale;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
902 }
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
903 /* B C
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
904 * A X
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
905 */
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
906 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
907 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
908
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
909 /* No prediction outside GOB boundary */
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
910 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
911 c = 1024;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
912 pred_dc = 1024;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
913 /* just DC prediction */
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
914 if (a != 1024 && c != 1024)
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
915 pred_dc = (a + c) >> 1;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
916 else if (a != 1024)
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
917 pred_dc = a;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
918 else
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
919 pred_dc = c;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
920
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
921 /* we assume pred is positive */
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
922 //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
923 *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
924 return pred_dc;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
925 }
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
926
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
927
249
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
928 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
929 {
249
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
930 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
931 INT16 *dc_val, *ac_val, *ac_val1;
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
932
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
933 /* find prediction */
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
934 if (n < 4) {
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
935 x = 2 * s->mb_x + 1 + (n & 1);
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
936 y = 2 * s->mb_y + 1 + ((n & 2) >> 1);
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
937 wrap = s->mb_width * 2 + 2;
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
938 dc_val = s->dc_val[0];
249
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
939 ac_val = s->ac_val[0][0];
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
940 scale = s->y_dc_scale;
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
941 } else {
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
942 x = s->mb_x + 1;
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
943 y = s->mb_y + 1;
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
944 wrap = s->mb_width + 2;
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
945 dc_val = s->dc_val[n - 4 + 1];
249
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
946 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
947 scale = s->c_dc_scale;
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
948 }
249
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
949
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
950 ac_val += ((y) * wrap + (x)) * 16;
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
951 ac_val1 = ac_val;
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
952
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
953 /* B C
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
954 * A X
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
955 */
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
956 a = dc_val[(x - 1) + (y) * wrap];
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
957 c = dc_val[(x) + (y - 1) * wrap];
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
958
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
959 /* No prediction outside GOB boundary */
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
960 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
961 c = 1024;
249
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
962 pred_dc = 1024;
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
963 if (s->ac_pred) {
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
964 if (s->h263_aic_dir) {
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
965 /* left prediction */
249
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
966 if (a != 1024) {
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
967 ac_val -= 16;
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
968 for(i=1;i<8;i++) {
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
969 block[s->idct_permutation[i<<3]] += ac_val[i];
249
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
970 }
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
971 pred_dc = a;
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
972 }
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
973 } else {
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
974 /* top prediction */
249
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
975 if (c != 1024) {
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
976 ac_val -= 16 * wrap;
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
977 for(i=1;i<8;i++) {
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
978 block[s->idct_permutation[i ]] += ac_val[i + 8];
249
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
979 }
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
980 pred_dc = c;
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
981 }
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
982 }
249
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
983 } else {
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
984 /* just DC prediction */
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
985 if (a != 1024 && c != 1024)
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
986 pred_dc = (a + c) >> 1;
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
987 else if (a != 1024)
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
988 pred_dc = a;
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
989 else
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
990 pred_dc = c;
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
991 }
249
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
992
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
993 /* we assume pred is positive */
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
994 block[0]=block[0]*scale + pred_dc;
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
995
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
996 if (block[0] < 0)
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
997 block[0] = 0;
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
998 else if (!(block[0] & 1))
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
999 block[0]++;
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1000
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1001 /* Update AC/DC tables */
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1002 dc_val[(x) + (y) * wrap] = block[0];
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1003
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1004 /* left copy */
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1005 for(i=1;i<8;i++)
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
1006 ac_val1[i ] = block[s->idct_permutation[i<<3]];
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1007 /* top copy */
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1008 for(i=1;i<8;i++)
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
1009 ac_val1[8 + i] = block[s->idct_permutation[i ]];
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1010 }
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1011
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1012 INT16 *h263_pred_motion(MpegEncContext * s, int block,
986e461dc072 Initial revision
glantau
parents:
diff changeset
1013 int *px, int *py)
986e461dc072 Initial revision
glantau
parents:
diff changeset
1014 {
266
252444e5259b optimization
michaelni
parents: 265
diff changeset
1015 int xy, wrap;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1016 INT16 *A, *B, *C, *mot_val;
264
28c5c62b1c4c support decoding (with mplayer) of 3 .mp4 files from mphq
michaelni
parents: 263
diff changeset
1017 static const int off[4]= {2, 1, 1, -1};
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1018
266
252444e5259b optimization
michaelni
parents: 265
diff changeset
1019 wrap = s->block_wrap[0];
252444e5259b optimization
michaelni
parents: 265
diff changeset
1020 xy = s->block_index[block];
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1021
245
a023f78e0cc2 * simplified indexing
kabi
parents: 241
diff changeset
1022 mot_val = s->motion_val[xy];
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1023
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1024 A = s->motion_val[xy - 1];
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1025 /* special case for first (slice) line */
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
1026 if (s->first_slice_line && block<3) {
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1027 // 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
1028 // 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
1029 if(block==0){ //most common case
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1030 if(s->mb_x == s->resync_mb_x){ //rare
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1031 *px= *py = 0;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1032 }else if(s->mb_x + 1 == s->resync_mb_x){ //rare
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1033 C = s->motion_val[xy + off[block] - wrap];
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1034 if(s->mb_x==0){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1035 *px = C[0];
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1036 *py = C[1];
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1037 }else{
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1038 *px = mid_pred(A[0], 0, C[0]);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1039 *py = mid_pred(A[1], 0, C[1]);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1040 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1041 }else{
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1042 *px = A[0];
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1043 *py = A[1];
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1044 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1045 }else if(block==1){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1046 if(s->mb_x + 1 == s->resync_mb_x){ //rare
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1047 C = s->motion_val[xy + off[block] - wrap];
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1048 *px = mid_pred(A[0], 0, C[0]);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1049 *py = mid_pred(A[1], 0, C[1]);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1050 }else{
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1051 *px = A[0];
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1052 *py = A[1];
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1053 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1054 }else{ /* block==2*/
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1055 B = s->motion_val[xy - wrap];
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1056 C = s->motion_val[xy + off[block] - wrap];
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1057 if(s->mb_x == s->resync_mb_x) //rare
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1058 A[0]=A[1]=0;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1059
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1060 *px = mid_pred(A[0], B[0], C[0]);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1061 *py = mid_pred(A[1], B[1], C[1]);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1062 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1063 } else {
264
28c5c62b1c4c support decoding (with mplayer) of 3 .mp4 files from mphq
michaelni
parents: 263
diff changeset
1064 B = s->motion_val[xy - wrap];
28c5c62b1c4c support decoding (with mplayer) of 3 .mp4 files from mphq
michaelni
parents: 263
diff changeset
1065 C = s->motion_val[xy + off[block] - wrap];
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1066 *px = mid_pred(A[0], B[0], C[0]);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1067 *py = mid_pred(A[1], B[1], C[1]);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1068 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1069 return mot_val;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1070 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1071
815
78accc54493b put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents: 770
diff changeset
1072 #ifdef CONFIG_ENCODERS
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
1073 static void h263_encode_motion(MpegEncContext * s, int val, int f_code)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1074 {
702
2cff6fc37716 minor optimization of h263_encode_motion()
michaelni
parents: 701
diff changeset
1075 int range, l, bit_size, sign, code, bits;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1076
986e461dc072 Initial revision
glantau
parents:
diff changeset
1077 if (val == 0) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1078 /* zero vector */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1079 code = 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1080 put_bits(&s->pb, mvtab[code][1], mvtab[code][0]);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1081 } else {
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
1082 bit_size = f_code - 1;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1083 range = 1 << bit_size;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1084 /* modulo encoding */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1085 l = range * 32;
702
2cff6fc37716 minor optimization of h263_encode_motion()
michaelni
parents: 701
diff changeset
1086 #if 1
2cff6fc37716 minor optimization of h263_encode_motion()
michaelni
parents: 701
diff changeset
1087 val+= l;
2cff6fc37716 minor optimization of h263_encode_motion()
michaelni
parents: 701
diff changeset
1088 val&= 2*l-1;
2cff6fc37716 minor optimization of h263_encode_motion()
michaelni
parents: 701
diff changeset
1089 val-= l;
2cff6fc37716 minor optimization of h263_encode_motion()
michaelni
parents: 701
diff changeset
1090 sign = val>>31;
2cff6fc37716 minor optimization of h263_encode_motion()
michaelni
parents: 701
diff changeset
1091 val= (val^sign)-sign;
2cff6fc37716 minor optimization of h263_encode_motion()
michaelni
parents: 701
diff changeset
1092 sign&=1;
2cff6fc37716 minor optimization of h263_encode_motion()
michaelni
parents: 701
diff changeset
1093 #else
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1094 if (val < -l) {
702
2cff6fc37716 minor optimization of h263_encode_motion()
michaelni
parents: 701
diff changeset
1095 val += 2*l;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1096 } else if (val >= l) {
702
2cff6fc37716 minor optimization of h263_encode_motion()
michaelni
parents: 701
diff changeset
1097 val -= 2*l;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1098 }
702
2cff6fc37716 minor optimization of h263_encode_motion()
michaelni
parents: 701
diff changeset
1099
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
1100 assert(val>=-l && val<l);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1101
986e461dc072 Initial revision
glantau
parents:
diff changeset
1102 if (val >= 0) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1103 sign = 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1104 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1105 val = -val;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1106 sign = 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1107 }
702
2cff6fc37716 minor optimization of h263_encode_motion()
michaelni
parents: 701
diff changeset
1108 #endif
312
8cf5507e6ca5 mpeg4 mpeg quantizer support
michaelni
parents: 301
diff changeset
1109 val--;
8cf5507e6ca5 mpeg4 mpeg quantizer support
michaelni
parents: 301
diff changeset
1110 code = (val >> bit_size) + 1;
8cf5507e6ca5 mpeg4 mpeg quantizer support
michaelni
parents: 301
diff changeset
1111 bits = val & (range - 1);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1112
986e461dc072 Initial revision
glantau
parents:
diff changeset
1113 put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1114 if (bit_size > 0) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1115 put_bits(&s->pb, bit_size, bits);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1116 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1117 }
718
16dab8296293 fixing custom quantizer matrix decoding
michaelni
parents: 706
diff changeset
1118
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1119 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1120
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1121 /* Encode MV differences on H.263+ with Unrestricted MV mode */
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1122 static void h263p_encode_umotion(MpegEncContext * s, int val)
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1123 {
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1124 short sval = 0;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1125 short i = 0;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1126 short n_bits = 0;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1127 short temp_val;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1128 int code = 0;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1129 int tcode;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1130
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1131 if ( val == 0)
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1132 put_bits(&s->pb, 1, 1);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1133 else if (val == 1)
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1134 put_bits(&s->pb, 3, 0);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1135 else if (val == -1)
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1136 put_bits(&s->pb, 3, 2);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1137 else {
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1138
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1139 sval = ((val < 0) ? (short)(-val):(short)val);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1140 temp_val = sval;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1141
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1142 while (temp_val != 0) {
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1143 temp_val = temp_val >> 1;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1144 n_bits++;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1145 }
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1146
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1147 i = n_bits - 1;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1148 while (i > 0) {
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1149 tcode = (sval & (1 << (i-1))) >> (i-1);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1150 tcode = (tcode << 1) | 1;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1151 code = (code << 2) | tcode;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1152 i--;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1153 }
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1154 code = ((code << 1) | (val < 0)) << 1;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1155 put_bits(&s->pb, (2*n_bits)+1, code);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1156 //printf("\nVal = %d\tCode = %d", sval, code);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1157 }
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1158 }
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1159
277
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1160 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
1161 {
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1162 int f_code;
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1163 int mv;
815
78accc54493b put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents: 770
diff changeset
1164
78accc54493b put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents: 770
diff changeset
1165 if(mv_penalty==NULL)
78accc54493b put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents: 770
diff changeset
1166 mv_penalty= av_mallocz( sizeof(UINT16)*(MAX_FCODE+1)*(2*MAX_MV+1) );
78accc54493b put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents: 770
diff changeset
1167
277
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1168 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
1169 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
1170 int len;
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1171
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1172 if(mv==0) len= mvtab[0][1];
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1173 else{
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1174 int val, bit_size, range, code;
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1175
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1176 bit_size = s->f_code - 1;
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1177 range = 1 << bit_size;
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1178
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1179 val=mv;
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1180 if (val < 0)
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1181 val = -val;
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1182 val--;
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1183 code = (val >> bit_size) + 1;
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1184 if(code<33){
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1185 len= mvtab[code][1] + 1 + bit_size;
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1186 }else{
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1187 len= mvtab[32][1] + 2 + bit_size;
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1188 }
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1189 }
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1190
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1191 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
1192 }
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1193 }
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1194
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1195 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
1196 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
1197 fcode_tab[mv+MAX_MV]= f_code;
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1198 }
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1199 }
287
32a3dcce2e9b fixing motion estimation with h263p hopefully
michaelni
parents: 286
diff changeset
1200
32a3dcce2e9b fixing motion estimation with h263p hopefully
michaelni
parents: 286
diff changeset
1201 for(mv=0; mv<MAX_MV*2+1; mv++){
32a3dcce2e9b fixing motion estimation with h263p hopefully
michaelni
parents: 286
diff changeset
1202 umv_fcode_tab[mv]= 1;
32a3dcce2e9b fixing motion estimation with h263p hopefully
michaelni
parents: 286
diff changeset
1203 }
277
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1204 }
815
78accc54493b put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents: 770
diff changeset
1205 #endif
277
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1206
468
1e23eae32087 Minor warning cleanup.
mellum
parents: 453
diff changeset
1207 static void init_uni_dc_tab(void)
293
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1208 {
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1209 int level, uni_code, uni_len;
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1210
312
8cf5507e6ca5 mpeg4 mpeg quantizer support
michaelni
parents: 301
diff changeset
1211 for(level=-256; level<256; level++){
293
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1212 int size, v, l;
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1213 /* find number of bits */
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1214 size = 0;
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1215 v = abs(level);
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1216 while (v) {
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1217 v >>= 1;
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1218 size++;
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1219 }
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1220
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1221 if (level < 0)
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1222 l= (-level) ^ ((1 << size) - 1);
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1223 else
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1224 l= level;
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1225
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1226 /* luminance */
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1227 uni_code= DCtab_lum[size][0];
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1228 uni_len = DCtab_lum[size][1];
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1229
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1230 if (size > 0) {
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1231 uni_code<<=size; uni_code|=l;
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1232 uni_len+=size;
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1233 if (size > 8){
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1234 uni_code<<=1; uni_code|=1;
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1235 uni_len++;
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1236 }
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1237 }
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1238 uni_DCtab_lum[level+256][0]= uni_code;
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1239 uni_DCtab_lum[level+256][1]= uni_len;
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1240
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1241 /* chrominance */
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1242 uni_code= DCtab_chrom[size][0];
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1243 uni_len = DCtab_chrom[size][1];
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1244
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1245 if (size > 0) {
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1246 uni_code<<=size; uni_code|=l;
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1247 uni_len+=size;
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1248 if (size > 8){
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1249 uni_code<<=1; uni_code|=1;
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1250 uni_len++;
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1251 }
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1252 }
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1253 uni_DCtab_chrom[level+256][0]= uni_code;
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1254 uni_DCtab_chrom[level+256][1]= uni_len;
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1255
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1256 }
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1257 }
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1258
815
78accc54493b put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents: 770
diff changeset
1259 #ifdef CONFIG_ENCODERS
648
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1260 static void init_uni_mpeg4_rl_tab(RLTable *rl, UINT32 *bits_tab, UINT8 *len_tab){
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1261 int slevel, run, last;
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1262
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1263 assert(MAX_LEVEL >= 64);
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1264 assert(MAX_RUN >= 63);
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1265
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1266 for(slevel=-64; slevel<64; slevel++){
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1267 if(slevel==0) continue;
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1268 for(run=0; run<64; run++){
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1269 for(last=0; last<=1; last++){
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1270 const int index= UNI_MPEG4_ENC_INDEX(last, run, slevel+64);
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1271 int level= slevel < 0 ? -slevel : slevel;
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1272 int sign= slevel < 0 ? 1 : 0;
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1273 int bits, len, code;
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1274 int level1, run1;
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1275
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1276 len_tab[index]= 100;
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1277
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1278 /* ESC0 */
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1279 code= get_rl_index(rl, last, run, level);
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1280 bits= rl->table_vlc[code][0];
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1281 len= rl->table_vlc[code][1];
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1282 bits=bits*2+sign; len++;
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1283
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1284 if(code!=rl->n && len < len_tab[index]){
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1285 bits_tab[index]= bits;
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1286 len_tab [index]= len;
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1287 }
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1288 #if 1
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1289 /* ESC1 */
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1290 bits= rl->table_vlc[rl->n][0];
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1291 len= rl->table_vlc[rl->n][1];
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1292 bits=bits*2; len++; //esc1
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1293 level1= level - rl->max_level[last][run];
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1294 if(level1>0){
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1295 code= get_rl_index(rl, last, run, level1);
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1296 bits<<= rl->table_vlc[code][1];
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1297 len += rl->table_vlc[code][1];
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1298 bits += rl->table_vlc[code][0];
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1299 bits=bits*2+sign; len++;
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1300
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1301 if(code!=rl->n && len < len_tab[index]){
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1302 bits_tab[index]= bits;
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1303 len_tab [index]= len;
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1304 }
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1305 }
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1306 #endif
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1307 #if 1
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1308 /* ESC2 */
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1309 bits= rl->table_vlc[rl->n][0];
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1310 len= rl->table_vlc[rl->n][1];
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1311 bits=bits*4+2; len+=2; //esc2
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1312 run1 = run - rl->max_run[last][level] - 1;
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1313 if(run1>=0){
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1314 code= get_rl_index(rl, last, run1, level);
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1315 bits<<= rl->table_vlc[code][1];
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1316 len += rl->table_vlc[code][1];
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1317 bits += rl->table_vlc[code][0];
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1318 bits=bits*2+sign; len++;
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1319
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1320 if(code!=rl->n && len < len_tab[index]){
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1321 bits_tab[index]= bits;
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1322 len_tab [index]= len;
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1323 }
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1324 }
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1325 #endif
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1326 /* ESC3 */
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1327 bits= rl->table_vlc[rl->n][0];
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1328 len = rl->table_vlc[rl->n][1];
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1329 bits=bits*4+3; len+=2; //esc3
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1330 bits=bits*2+last; len++;
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1331 bits=bits*64+run; len+=6;
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1332 bits=bits*2+1; len++; //marker
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1333 bits=bits*4096+(slevel&0xfff); len+=12;
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1334 bits=bits*2+1; len++; //marker
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1335
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1336 if(len < len_tab[index]){
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1337 bits_tab[index]= bits;
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1338 len_tab [index]= len;
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1339 }
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1340 }
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1341 }
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1342 }
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1343 }
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1344
277
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1345 void h263_encode_init(MpegEncContext *s)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1346 {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1347 static int done = 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1348
986e461dc072 Initial revision
glantau
parents:
diff changeset
1349 if (!done) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1350 done = 1;
293
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1351
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1352 init_uni_dc_tab();
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1353
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1354 init_rl(&rl_inter);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1355 init_rl(&rl_intra);
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1356 init_rl(&rl_intra_aic);
648
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1357
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1358 init_uni_mpeg4_rl_tab(&rl_intra, uni_mpeg4_intra_rl_bits, uni_mpeg4_intra_rl_len);
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1359 init_uni_mpeg4_rl_tab(&rl_inter, uni_mpeg4_inter_rl_bits, uni_mpeg4_inter_rl_len);
277
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1360
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1361 init_mv_penalty_and_fcode(s);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1362 }
287
32a3dcce2e9b fixing motion estimation with h263p hopefully
michaelni
parents: 286
diff changeset
1363 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
1364
287
32a3dcce2e9b fixing motion estimation with h263p hopefully
michaelni
parents: 286
diff changeset
1365 // use fcodes >1 only for mpeg4 & h263 & h263p FIXME
344
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
1366 switch(s->codec_id){
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
1367 case CODEC_ID_MPEG4:
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
1368 s->fcode_tab= fcode_tab;
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
1369 s->min_qcoeff= -2048;
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
1370 s->max_qcoeff= 2047;
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
1371 break;
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
1372 case CODEC_ID_H263P:
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
1373 s->fcode_tab= umv_fcode_tab;
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
1374 s->min_qcoeff= -128;
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
1375 s->max_qcoeff= 127;
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
1376 break;
498
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
1377 //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
1378 default: //nothing needed default table allready set in mpegvideo.c
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
1379 s->min_qcoeff= -128;
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
1380 s->max_qcoeff= 127;
498
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
1381 s->y_dc_scale_table=
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
1382 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
344
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
1383 }
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
1384
599
b1a191202f96 mpeg4 mpeg quantizer encoding
michaelni
parents: 598
diff changeset
1385 if(s->mpeg_quant){
b1a191202f96 mpeg4 mpeg quantizer encoding
michaelni
parents: 598
diff changeset
1386 s->intra_quant_bias= 3<<(QUANT_BIAS_SHIFT-3); //(a + x*3/8)/x
b1a191202f96 mpeg4 mpeg quantizer encoding
michaelni
parents: 598
diff changeset
1387 s->inter_quant_bias= 0;
b1a191202f96 mpeg4 mpeg quantizer encoding
michaelni
parents: 598
diff changeset
1388 }else{
b1a191202f96 mpeg4 mpeg quantizer encoding
michaelni
parents: 598
diff changeset
1389 s->intra_quant_bias=0;
b1a191202f96 mpeg4 mpeg quantizer encoding
michaelni
parents: 598
diff changeset
1390 s->inter_quant_bias=-(1<<(QUANT_BIAS_SHIFT-2)); //(a - x/4)/x
b1a191202f96 mpeg4 mpeg quantizer encoding
michaelni
parents: 598
diff changeset
1391 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1392 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1393
986e461dc072 Initial revision
glantau
parents:
diff changeset
1394 static void h263_encode_block(MpegEncContext * s, DCTELEM * block, int n)
986e461dc072 Initial revision
glantau
parents:
diff changeset
1395 {
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1396 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
1397 RLTable *rl;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1398
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1399 rl = &rl_inter;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1400 if (s->mb_intra && !s->h263_aic) {
231
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
1401 /* DC coef */
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
1402 level = block[0];
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1403 /* 255 cannot be represented, so we clamp */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1404 if (level > 254) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1405 level = 254;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1406 block[0] = 254;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1407 }
231
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
1408 /* 0 cannot be represented also */
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
1409 else if (!level) {
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
1410 level = 1;
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
1411 block[0] = 1;
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
1412 }
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
1413 if (level == 128)
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
1414 put_bits(&s->pb, 8, 0xff);
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
1415 else
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
1416 put_bits(&s->pb, 8, level & 0xff);
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
1417 i = 1;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1418 } else {
231
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
1419 i = 0;
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1420 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
1421 rl = &rl_intra_aic;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1422 }
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1423
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1424 /* AC coefs */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1425 last_index = s->block_last_index[n];
986e461dc072 Initial revision
glantau
parents:
diff changeset
1426 last_non_zero = i - 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1427 for (; i <= last_index; i++) {
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
1428 j = s->intra_scantable.permutated[i];
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1429 level = block[j];
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1430 if (level) {
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1431 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
1432 last = (i == last_index);
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1433 sign = 0;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1434 slevel = level;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1435 if (level < 0) {
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1436 sign = 1;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1437 level = -level;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1438 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1439 code = get_rl_index(rl, last, run, level);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1440 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1441 if (code == rl->n) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1442 put_bits(&s->pb, 1, last);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1443 put_bits(&s->pb, 6, run);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1444 put_bits(&s->pb, 8, slevel & 0xff);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1445 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1446 put_bits(&s->pb, 1, sign);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1447 }
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1448 last_non_zero = i;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1449 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1450 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1451 }
815
78accc54493b put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents: 770
diff changeset
1452 #endif
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1453
986e461dc072 Initial revision
glantau
parents:
diff changeset
1454 /***************************************************/
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
1455 /**
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
1456 * add mpeg4 stuffing bits (01...1)
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
1457 */
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1458 void ff_mpeg4_stuffing(PutBitContext * pbc)
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1459 {
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1460 int length;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1461 put_bits(pbc, 1, 0);
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1462 length= (-get_bit_count(pbc))&7;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1463 if(length) put_bits(pbc, length, (1<<length)-1);
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1464 }
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1465
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
1466 /* must be called before writing the header */
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
1467 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
1468 int time_div, time_mod;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
1469
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
1470 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
1471 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
1472 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
1473
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
1474 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
1475 }
654
850098147a3c export pts from stream if available
michaelni
parents: 648
diff changeset
1476
850098147a3c export pts from stream if available
michaelni
parents: 648
diff changeset
1477 if(s->avctx->pts)
850098147a3c export pts from stream if available
michaelni
parents: 648
diff changeset
1478 s->time= (s->avctx->pts*s->time_increment_resolution + 500*1000)/(1000*1000);
850098147a3c export pts from stream if available
michaelni
parents: 648
diff changeset
1479 else
850098147a3c export pts from stream if available
michaelni
parents: 648
diff changeset
1480 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
1481 time_div= s->time/s->time_increment_resolution;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
1482 time_mod= s->time%s->time_increment_resolution;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
1483
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
1484 if(s->pict_type==B_TYPE){
664
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
1485 s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
1486 }else{
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
1487 s->last_time_base= s->time_base;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
1488 s->time_base= time_div;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
1489 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
1490 s->last_non_b_time= s->time;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
1491 }
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
1492 }
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
1493
263
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1494 static void mpeg4_encode_vol_header(MpegEncContext * s)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1495 {
263
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1496 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
1497 char buf[255];
336
c56b45669214 export delay info
michaelni
parents: 335
diff changeset
1498
c56b45669214 export delay info
michaelni
parents: 335
diff changeset
1499 s->vo_type= s->has_b_frames ? CORE_VO_TYPE : SIMPLE_VO_TYPE;
c56b45669214 export delay info
michaelni
parents: 335
diff changeset
1500
263
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1501 put_bits(&s->pb, 16, 0);
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1502 put_bits(&s->pb, 16, 0x100); /* video obj */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1503 put_bits(&s->pb, 16, 0);
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1504 put_bits(&s->pb, 16, 0x120); /* video obj layer */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1505
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1506 put_bits(&s->pb, 1, 0); /* random access vol */
336
c56b45669214 export delay info
michaelni
parents: 335
diff changeset
1507 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
1508 put_bits(&s->pb, 1, 1); /* is obj layer id= yes */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1509 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
1510 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
1511 if(s->aspect_ratio_info)
1fc96b02142e mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents: 278
diff changeset
1512 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
1513 else
1fc96b02142e mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents: 278
diff changeset
1514 put_bits(&s->pb, 4, 1); /* aspect ratio info= sqare pixel */
669
b4bddbde44f3 aspect (ext. par too) support for h263 and mpeg4 (inc. build becouse of new vars)
al3x
parents: 667
diff changeset
1515 if (s->aspect_ratio_info == FF_ASPECT_EXTENDED)
b4bddbde44f3 aspect (ext. par too) support for h263 and mpeg4 (inc. build becouse of new vars)
al3x
parents: 667
diff changeset
1516 {
b4bddbde44f3 aspect (ext. par too) support for h263 and mpeg4 (inc. build becouse of new vars)
al3x
parents: 667
diff changeset
1517 put_bits(&s->pb, 8, s->aspected_width);
b4bddbde44f3 aspect (ext. par too) support for h263 and mpeg4 (inc. build becouse of new vars)
al3x
parents: 667
diff changeset
1518 put_bits(&s->pb, 8, s->aspected_height);
b4bddbde44f3 aspect (ext. par too) support for h263 and mpeg4 (inc. build becouse of new vars)
al3x
parents: 667
diff changeset
1519 }
336
c56b45669214 export delay info
michaelni
parents: 335
diff changeset
1520
c56b45669214 export delay info
michaelni
parents: 335
diff changeset
1521 if(s->low_delay){
c56b45669214 export delay info
michaelni
parents: 335
diff changeset
1522 put_bits(&s->pb, 1, 1); /* vol control parameters= yes */
341
bf26081c373c avcodec_flush_buffers()
michaelni
parents: 339
diff changeset
1523 put_bits(&s->pb, 2, 1); /* chroma format YUV 420/YV12 */
336
c56b45669214 export delay info
michaelni
parents: 335
diff changeset
1524 put_bits(&s->pb, 1, s->low_delay);
c56b45669214 export delay info
michaelni
parents: 335
diff changeset
1525 put_bits(&s->pb, 1, 0); /* vbv parameters= no */
c56b45669214 export delay info
michaelni
parents: 335
diff changeset
1526 }else{
c56b45669214 export delay info
michaelni
parents: 335
diff changeset
1527 put_bits(&s->pb, 1, 0); /* vol control parameters= no */
c56b45669214 export delay info
michaelni
parents: 335
diff changeset
1528 }
c56b45669214 export delay info
michaelni
parents: 335
diff changeset
1529
263
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1530 put_bits(&s->pb, 2, RECT_SHAPE); /* vol shape= rectangle */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1531 put_bits(&s->pb, 1, 1); /* marker bit */
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
1532
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
1533 put_bits(&s->pb, 16, s->time_increment_resolution);
263
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1534 if (s->time_increment_bits < 1)
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1535 s->time_increment_bits = 1;
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1536 put_bits(&s->pb, 1, 1); /* marker bit */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1537 put_bits(&s->pb, 1, 0); /* fixed vop rate=no */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1538 put_bits(&s->pb, 1, 1); /* marker bit */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1539 put_bits(&s->pb, 13, s->width); /* vol width */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1540 put_bits(&s->pb, 1, 1); /* marker bit */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1541 put_bits(&s->pb, 13, s->height); /* vol height */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1542 put_bits(&s->pb, 1, 1); /* marker bit */
697
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
1543 put_bits(&s->pb, 1, s->progressive_sequence ? 0 : 1);
263
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1544 put_bits(&s->pb, 1, 1); /* obmc disable */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1545 if (vo_ver_id == 1) {
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1546 put_bits(&s->pb, 1, s->vol_sprite_usage=0); /* sprite enable */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1547 }else{ /* vo_ver_id == 2 */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1548 put_bits(&s->pb, 2, s->vol_sprite_usage=0); /* sprite enable */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1549 }
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
1550
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
1551 s->quant_precision=5;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
1552 put_bits(&s->pb, 1, 0); /* not 8 bit == false */
599
b1a191202f96 mpeg4 mpeg quantizer encoding
michaelni
parents: 598
diff changeset
1553 put_bits(&s->pb, 1, s->mpeg_quant); /* quant type= (0=h263 style)*/
b1a191202f96 mpeg4 mpeg quantizer encoding
michaelni
parents: 598
diff changeset
1554 if(s->mpeg_quant) put_bits(&s->pb, 2, 0); /* no custom matrixes */
b1a191202f96 mpeg4 mpeg quantizer encoding
michaelni
parents: 598
diff changeset
1555
263
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1556 if (vo_ver_id != 1)
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1557 put_bits(&s->pb, 1, s->quarter_sample=0);
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1558 put_bits(&s->pb, 1, 1); /* complexity estimation disable */
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1559 s->resync_marker= s->rtp_mode;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1560 put_bits(&s->pb, 1, s->resync_marker ? 0 : 1);/* resync marker disable */
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1561 put_bits(&s->pb, 1, s->data_partitioning ? 1 : 0);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1562 if(s->data_partitioning){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1563 put_bits(&s->pb, 1, 0); /* no rvlc */
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1564 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1565
263
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1566 if (vo_ver_id != 1){
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1567 put_bits(&s->pb, 1, 0); /* newpred */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1568 put_bits(&s->pb, 1, 0); /* reduced res vop */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1569 }
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1570 put_bits(&s->pb, 1, 0); /* scalability */
676
c3bdb00a98a9 dont store version for bit-exact tests
michaelni
parents: 674
diff changeset
1571
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1572 ff_mpeg4_stuffing(&s->pb);
676
c3bdb00a98a9 dont store version for bit-exact tests
michaelni
parents: 674
diff changeset
1573
c3bdb00a98a9 dont store version for bit-exact tests
michaelni
parents: 674
diff changeset
1574 /* user data */
c3bdb00a98a9 dont store version for bit-exact tests
michaelni
parents: 674
diff changeset
1575 if(!ff_bit_exact){
c3bdb00a98a9 dont store version for bit-exact tests
michaelni
parents: 674
diff changeset
1576 put_bits(&s->pb, 16, 0);
c3bdb00a98a9 dont store version for bit-exact tests
michaelni
parents: 674
diff changeset
1577 put_bits(&s->pb, 16, 0x1B2); /* user_data */
c3bdb00a98a9 dont store version for bit-exact tests
michaelni
parents: 674
diff changeset
1578 sprintf(buf, "FFmpeg%sb%s", FFMPEG_VERSION, LIBAVCODEC_BUILD_STR);
c3bdb00a98a9 dont store version for bit-exact tests
michaelni
parents: 674
diff changeset
1579 put_string(&s->pb, buf);
c3bdb00a98a9 dont store version for bit-exact tests
michaelni
parents: 674
diff changeset
1580 ff_mpeg4_stuffing(&s->pb);
c3bdb00a98a9 dont store version for bit-exact tests
michaelni
parents: 674
diff changeset
1581 }
263
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1582 }
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1583
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1584 /* write mpeg4 VOP header */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1585 void mpeg4_encode_picture_header(MpegEncContext * s, int picture_number)
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1586 {
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
1587 int time_incr;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
1588 int time_div, time_mod;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
1589
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1590 if(s->pict_type==I_TYPE){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1591 s->no_rounding=0;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1592 if(picture_number==0 || !s->strict_std_compliance)
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1593 mpeg4_encode_vol_header(s);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1594 }
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
1595
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
1596 s->partitioned_frame= s->data_partitioning && s->pict_type!=B_TYPE;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
1597
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
1598 //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
1599
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
1600 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
1601 put_bits(&s->pb, 16, 0x1B6); /* vop header */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1602 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
1603
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
1604 time_div= s->time/s->time_increment_resolution;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
1605 time_mod= s->time%s->time_increment_resolution;
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
1606 time_incr= time_div - s->last_time_base;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
1607 while(time_incr--)
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
1608 put_bits(&s->pb, 1, 1);
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
1609
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1610 put_bits(&s->pb, 1, 0);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1611
986e461dc072 Initial revision
glantau
parents:
diff changeset
1612 put_bits(&s->pb, 1, 1); /* marker */
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
1613 put_bits(&s->pb, s->time_increment_bits, time_mod); /* time increment */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1614 put_bits(&s->pb, 1, 1); /* marker */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1615 put_bits(&s->pb, 1, 1); /* vop coded */
263
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1616 if ( s->pict_type == P_TYPE
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1617 || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE)) {
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1618 s->no_rounding ^= 1;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1619 put_bits(&s->pb, 1, s->no_rounding); /* rounding type */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1620 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1621 put_bits(&s->pb, 3, 0); /* intra dc VLC threshold */
697
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
1622 if(!s->progressive_sequence){
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
1623 put_bits(&s->pb, 1, s->top_field_first);
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
1624 put_bits(&s->pb, 1, s->alternate_scan);
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
1625 }
263
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1626 //FIXME sprite stuff
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1627
986e461dc072 Initial revision
glantau
parents:
diff changeset
1628 put_bits(&s->pb, 5, s->qscale);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1629
986e461dc072 Initial revision
glantau
parents:
diff changeset
1630 if (s->pict_type != I_TYPE)
986e461dc072 Initial revision
glantau
parents:
diff changeset
1631 put_bits(&s->pb, 3, s->f_code); /* fcode_for */
263
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1632 if (s->pict_type == B_TYPE)
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1633 put_bits(&s->pb, 3, s->b_code); /* fcode_back */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1634 // printf("****frame %d\n", picture_number);
498
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
1635
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
1636 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
1637 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
1638 s->h_edge_pos= s->width;
5132a4ee50cd different edge positions fixed with edge emu / dr1
michaelni
parents: 575
diff changeset
1639 s->v_edge_pos= s->height;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1640 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1641
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
1642 /**
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
1643 * change qscale by given dquant and update qscale dependant variables.
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
1644 */
698
e050a053e259 h263_dc_scale() cleanup
michaelni
parents: 697
diff changeset
1645 static void change_qscale(MpegEncContext * s, int dquant)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1646 {
698
e050a053e259 h263_dc_scale() cleanup
michaelni
parents: 697
diff changeset
1647 s->qscale += dquant;
e050a053e259 h263_dc_scale() cleanup
michaelni
parents: 697
diff changeset
1648
e050a053e259 h263_dc_scale() cleanup
michaelni
parents: 697
diff changeset
1649 if (s->qscale < 1)
e050a053e259 h263_dc_scale() cleanup
michaelni
parents: 697
diff changeset
1650 s->qscale = 1;
e050a053e259 h263_dc_scale() cleanup
michaelni
parents: 697
diff changeset
1651 else if (s->qscale > 31)
e050a053e259 h263_dc_scale() cleanup
michaelni
parents: 697
diff changeset
1652 s->qscale = 31;
e050a053e259 h263_dc_scale() cleanup
michaelni
parents: 697
diff changeset
1653
498
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
1654 s->y_dc_scale= s->y_dc_scale_table[ s->qscale ];
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
1655 s->c_dc_scale= s->c_dc_scale_table[ s->qscale ];
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1656 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1657
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
1658 static 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
1659 {
266
252444e5259b optimization
michaelni
parents: 265
diff changeset
1660 int a, b, c, wrap, pred, scale;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1661 UINT16 *dc_val;
469
a5dd4eae1f0c Revert previous bogus warning fix.
mellum
parents: 468
diff changeset
1662 int dummy;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1663
986e461dc072 Initial revision
glantau
parents:
diff changeset
1664 /* find prediction */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1665 if (n < 4) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1666 scale = s->y_dc_scale;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1667 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1668 scale = s->c_dc_scale;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1669 }
266
252444e5259b optimization
michaelni
parents: 265
diff changeset
1670 wrap= s->block_wrap[n];
252444e5259b optimization
michaelni
parents: 265
diff changeset
1671 dc_val = s->dc_val[0] + s->block_index[n];
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1672
986e461dc072 Initial revision
glantau
parents:
diff changeset
1673 /* B C
986e461dc072 Initial revision
glantau
parents:
diff changeset
1674 * A X
986e461dc072 Initial revision
glantau
parents:
diff changeset
1675 */
266
252444e5259b optimization
michaelni
parents: 265
diff changeset
1676 a = dc_val[ - 1];
252444e5259b optimization
michaelni
parents: 265
diff changeset
1677 b = dc_val[ - 1 - wrap];
252444e5259b optimization
michaelni
parents: 265
diff changeset
1678 c = dc_val[ - wrap];
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1679
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
1680 /* outside slice handling (we cant do that by memset as we need the dc for error resilience) */
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
1681 if(s->first_slice_line && n!=3){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
1682 if(n!=2) b=c= 1024;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
1683 if(n!=1 && s->mb_x == s->resync_mb_x) b=a= 1024;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
1684 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
1685 if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
1686 if(n==0 || n==4 || n==5)
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
1687 b=1024;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
1688 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
1689
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1690 if (abs(a - b) < abs(b - c)) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1691 pred = c;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1692 *dir_ptr = 1; /* top */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1693 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1694 pred = a;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1695 *dir_ptr = 0; /* left */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1696 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1697 /* we assume pred is positive */
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1698 #ifdef ARCH_X86
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1699 asm volatile (
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1700 "xorl %%edx, %%edx \n\t"
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1701 "mul %%ecx \n\t"
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1702 : "=d" (pred), "=a"(dummy)
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1703 : "a" (pred + (scale >> 1)), "c" (inverse[scale])
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1704 );
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1705 #else
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1706 pred = (pred + (scale >> 1)) / scale;
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1707 #endif
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1708
986e461dc072 Initial revision
glantau
parents:
diff changeset
1709 /* prepare address for prediction update */
266
252444e5259b optimization
michaelni
parents: 265
diff changeset
1710 *dc_val_ptr = &dc_val[0];
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1711
986e461dc072 Initial revision
glantau
parents:
diff changeset
1712 return pred;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1713 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1714
174
ac5075a55488 new IDCT code by Michael Niedermayer (michaelni@gmx.at) - #define SIMPLE_IDCT to enable
arpi_esp
parents: 162
diff changeset
1715 void mpeg4_pred_ac(MpegEncContext * s, INT16 *block, int n,
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1716 int dir)
986e461dc072 Initial revision
glantau
parents:
diff changeset
1717 {
266
252444e5259b optimization
michaelni
parents: 265
diff changeset
1718 int i;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1719 INT16 *ac_val, *ac_val1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1720
986e461dc072 Initial revision
glantau
parents:
diff changeset
1721 /* find prediction */
266
252444e5259b optimization
michaelni
parents: 265
diff changeset
1722 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1723 ac_val1 = ac_val;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1724 if (s->ac_pred) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1725 if (dir == 0) {
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
1726 const int xy= s->mb_x-1 + s->mb_y*s->mb_width;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1727 /* left prediction */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1728 ac_val -= 16;
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
1729
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
1730 if(s->mb_x==0 || s->qscale == s->qscale_table[xy] || n==1 || n==3){
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
1731 /* same qscale */
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
1732 for(i=1;i<8;i++) {
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
1733 block[s->idct_permutation[i<<3]] += ac_val[i];
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
1734 }
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
1735 }else{
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
1736 /* different qscale, we must rescale */
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
1737 for(i=1;i<8;i++) {
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
1738 block[s->idct_permutation[i<<3]] += ROUNDED_DIV(ac_val[i]*s->qscale_table[xy], s->qscale);
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
1739 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1740 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1741 } else {
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
1742 const int xy= s->mb_x + s->mb_y*s->mb_width - s->mb_width;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1743 /* top prediction */
266
252444e5259b optimization
michaelni
parents: 265
diff changeset
1744 ac_val -= 16 * s->block_wrap[n];
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
1745
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
1746 if(s->mb_y==0 || s->qscale == s->qscale_table[xy] || n==2 || n==3){
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
1747 /* same qscale */
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
1748 for(i=1;i<8;i++) {
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
1749 block[s->idct_permutation[i]] += ac_val[i + 8];
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
1750 }
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
1751 }else{
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
1752 /* different qscale, we must rescale */
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
1753 for(i=1;i<8;i++) {
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
1754 block[s->idct_permutation[i]] += ROUNDED_DIV(ac_val[i + 8]*s->qscale_table[xy], s->qscale);
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
1755 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1756 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1757 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1758 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1759 /* left copy */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1760 for(i=1;i<8;i++)
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
1761 ac_val1[i ] = block[s->idct_permutation[i<<3]];
591
d3f374218030 fixing mpeg4 mpeg quantizers
michaelni
parents: 582
diff changeset
1762
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1763 /* top copy */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1764 for(i=1;i<8;i++)
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
1765 ac_val1[8 + i] = block[s->idct_permutation[i ]];
591
d3f374218030 fixing mpeg4 mpeg quantizers
michaelni
parents: 582
diff changeset
1766
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1767 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1768
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1769 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
1770 int dir)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1771 {
266
252444e5259b optimization
michaelni
parents: 265
diff changeset
1772 int i;
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1773 INT16 *ac_val;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1774
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1775 /* find prediction */
266
252444e5259b optimization
michaelni
parents: 265
diff changeset
1776 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
1777
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1778 if (dir == 0) {
692
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
1779 const int xy= s->mb_x-1 + s->mb_y*s->mb_width;
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1780 /* left prediction */
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1781 ac_val -= 16;
692
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
1782 if(s->mb_x==0 || s->qscale == s->qscale_table[xy] || n==1 || n==3){
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
1783 /* same qscale */
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
1784 for(i=1;i<8;i++) {
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
1785 block[s->idct_permutation[i<<3]] -= ac_val[i];
692
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
1786 }
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
1787 }else{
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
1788 /* different qscale, we must rescale */
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
1789 for(i=1;i<8;i++) {
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
1790 block[s->idct_permutation[i<<3]] -= ROUNDED_DIV(ac_val[i]*s->qscale_table[xy], s->qscale);
692
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
1791 }
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1792 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1793 } else {
692
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
1794 const int xy= s->mb_x + s->mb_y*s->mb_width - s->mb_width;
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1795 /* top prediction */
266
252444e5259b optimization
michaelni
parents: 265
diff changeset
1796 ac_val -= 16 * s->block_wrap[n];
692
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
1797 if(s->mb_y==0 || s->qscale == s->qscale_table[xy] || n==2 || n==3){
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
1798 /* same qscale */
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
1799 for(i=1;i<8;i++) {
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
1800 block[s->idct_permutation[i]] -= ac_val[i + 8];
692
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
1801 }
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
1802 }else{
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
1803 /* different qscale, we must rescale */
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
1804 for(i=1;i<8;i++) {
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
1805 block[s->idct_permutation[i]] -= ROUNDED_DIV(ac_val[i + 8]*s->qscale_table[xy], s->qscale);
692
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
1806 }
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1807 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1808 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1809 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1810
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1811 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
1812 {
293
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1813 #if 1
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1814 // if(level<-255 || level>255) printf("dc overflow\n");
293
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1815 level+=256;
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1816 if (n < 4) {
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1817 /* luminance */
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1818 put_bits(s, uni_DCtab_lum[level][1], uni_DCtab_lum[level][0]);
293
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1819 } else {
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1820 /* chrominance */
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1821 put_bits(s, uni_DCtab_chrom[level][1], uni_DCtab_chrom[level][0]);
293
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1822 }
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1823 #else
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1824 int size, v;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1825 /* find number of bits */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1826 size = 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1827 v = abs(level);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1828 while (v) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1829 v >>= 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1830 size++;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1831 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1832
986e461dc072 Initial revision
glantau
parents:
diff changeset
1833 if (n < 4) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1834 /* luminance */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1835 put_bits(&s->pb, DCtab_lum[size][1], DCtab_lum[size][0]);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1836 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1837 /* chrominance */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1838 put_bits(&s->pb, DCtab_chrom[size][1], DCtab_chrom[size][0]);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1839 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1840
986e461dc072 Initial revision
glantau
parents:
diff changeset
1841 /* encode remaining bits */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1842 if (size > 0) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1843 if (level < 0)
986e461dc072 Initial revision
glantau
parents:
diff changeset
1844 level = (-level) ^ ((1 << size) - 1);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1845 put_bits(&s->pb, size, level);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1846 if (size > 8)
986e461dc072 Initial revision
glantau
parents:
diff changeset
1847 put_bits(&s->pb, 1, 1);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1848 }
293
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1849 #endif
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1850 }
815
78accc54493b put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents: 770
diff changeset
1851 #ifdef CONFIG_ENCODERS
648
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1852 static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n, int intra_dc,
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1853 UINT8 *scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1854 {
751
cbe316f082bc warning fixes
michaelni
parents: 747
diff changeset
1855 int i, last_non_zero;
cbe316f082bc warning fixes
michaelni
parents: 747
diff changeset
1856 #if 0 //variables for the outcommented version
cbe316f082bc warning fixes
michaelni
parents: 747
diff changeset
1857 int code, sign, last;
cbe316f082bc warning fixes
michaelni
parents: 747
diff changeset
1858 #endif
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1859 const RLTable *rl;
648
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1860 UINT32 *bits_tab;
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1861 UINT8 *len_tab;
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1862 const int last_index = s->block_last_index[n];
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1863
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1864 if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1865 /* mpeg4 based DC predictor */
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1866 mpeg4_encode_dc(dc_pb, intra_dc, n);
648
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1867 if(last_index<1) return;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1868 i = 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1869 rl = &rl_intra;
648
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1870 bits_tab= uni_mpeg4_intra_rl_bits;
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1871 len_tab = uni_mpeg4_intra_rl_len;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1872 } else {
648
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1873 if(last_index<0) return;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1874 i = 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1875 rl = &rl_inter;
648
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1876 bits_tab= uni_mpeg4_inter_rl_bits;
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1877 len_tab = uni_mpeg4_inter_rl_len;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1878 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1879
986e461dc072 Initial revision
glantau
parents:
diff changeset
1880 /* AC coefs */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1881 last_non_zero = i - 1;
648
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1882 #if 1
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1883 for (; i < last_index; i++) {
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1884 int level = block[ scan_table[i] ];
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1885 if (level) {
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1886 int run = i - last_non_zero - 1;
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1887 level+=64;
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1888 if((level&(~127)) == 0){
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1889 const int index= UNI_MPEG4_ENC_INDEX(0, run, level);
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1890 put_bits(ac_pb, len_tab[index], bits_tab[index]);
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1891 }else{ //ESC3
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1892 put_bits(ac_pb, 7+2+1+6+1+12+1, (3<<23)+(3<<21)+(0<<20)+(run<<14)+(1<<13)+(((level-64)&0xfff)<<1)+1);
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1893 }
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1894 last_non_zero = i;
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1895 }
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1896 }
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1897 /*if(i<=last_index)*/{
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1898 int level = block[ scan_table[i] ];
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1899 int run = i - last_non_zero - 1;
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1900 level+=64;
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1901 if((level&(~127)) == 0){
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1902 const int index= UNI_MPEG4_ENC_INDEX(1, run, level);
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1903 put_bits(ac_pb, len_tab[index], bits_tab[index]);
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1904 }else{ //ESC3
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1905 put_bits(ac_pb, 7+2+1+6+1+12+1, (3<<23)+(3<<21)+(1<<20)+(run<<14)+(1<<13)+(((level-64)&0xfff)<<1)+1);
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1906 }
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1907 }
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1908 #else
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1909 for (; i <= last_index; i++) {
648
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1910 const int slevel = block[ scan_table[i] ];
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1911 if (slevel) {
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1912 int level;
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1913 int run = i - last_non_zero - 1;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1914 last = (i == last_index);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1915 sign = 0;
648
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1916 level = slevel;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1917 if (level < 0) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1918 sign = 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1919 level = -level;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1920 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1921 code = get_rl_index(rl, last, run, level);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1922 put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1923 if (code == rl->n) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1924 int level1, run1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1925 level1 = level - rl->max_level[last][run];
986e461dc072 Initial revision
glantau
parents:
diff changeset
1926 if (level1 < 1)
986e461dc072 Initial revision
glantau
parents:
diff changeset
1927 goto esc2;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1928 code = get_rl_index(rl, last, run, level1);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1929 if (code == rl->n) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1930 esc2:
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1931 put_bits(ac_pb, 1, 1);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1932 if (level > MAX_LEVEL)
986e461dc072 Initial revision
glantau
parents:
diff changeset
1933 goto esc3;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1934 run1 = run - rl->max_run[last][level] - 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1935 if (run1 < 0)
986e461dc072 Initial revision
glantau
parents:
diff changeset
1936 goto esc3;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1937 code = get_rl_index(rl, last, run1, level);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1938 if (code == rl->n) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1939 esc3:
986e461dc072 Initial revision
glantau
parents:
diff changeset
1940 /* third escape */
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1941 put_bits(ac_pb, 1, 1);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1942 put_bits(ac_pb, 1, last);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1943 put_bits(ac_pb, 6, run);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1944 put_bits(ac_pb, 1, 1);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1945 put_bits(ac_pb, 12, slevel & 0xfff);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1946 put_bits(ac_pb, 1, 1);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1947 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1948 /* second escape */
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1949 put_bits(ac_pb, 1, 0);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1950 put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1951 put_bits(ac_pb, 1, sign);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1952 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1953 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1954 /* first escape */
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1955 put_bits(ac_pb, 1, 0);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1956 put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1957 put_bits(ac_pb, 1, sign);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1958 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1959 } else {
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1960 put_bits(ac_pb, 1, sign);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1961 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1962 last_non_zero = i;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1963 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1964 }
648
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1965 #endif
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1966 }
815
78accc54493b put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents: 770
diff changeset
1967 #endif
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1968
986e461dc072 Initial revision
glantau
parents:
diff changeset
1969
986e461dc072 Initial revision
glantau
parents:
diff changeset
1970 /***********************************************/
986e461dc072 Initial revision
glantau
parents:
diff changeset
1971 /* decoding */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1972
986e461dc072 Initial revision
glantau
parents:
diff changeset
1973 static VLC intra_MCBPC_vlc;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1974 static VLC inter_MCBPC_vlc;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1975 static VLC cbpy_vlc;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1976 static VLC mv_vlc;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1977 static VLC dc_lum, dc_chrom;
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
1978 static VLC sprite_trajectory;
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1979 static VLC mb_type_b_vlc;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1980
986e461dc072 Initial revision
glantau
parents:
diff changeset
1981 void init_rl(RLTable *rl)
986e461dc072 Initial revision
glantau
parents:
diff changeset
1982 {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1983 INT8 max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
986e461dc072 Initial revision
glantau
parents:
diff changeset
1984 UINT8 index_run[MAX_RUN+1];
986e461dc072 Initial revision
glantau
parents:
diff changeset
1985 int last, run, level, start, end, i;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1986
986e461dc072 Initial revision
glantau
parents:
diff changeset
1987 /* compute max_level[], max_run[] and index_run[] */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1988 for(last=0;last<2;last++) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1989 if (last == 0) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1990 start = 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1991 end = rl->last;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1992 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1993 start = rl->last;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1994 end = rl->n;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1995 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1996
986e461dc072 Initial revision
glantau
parents:
diff changeset
1997 memset(max_level, 0, MAX_RUN + 1);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1998 memset(max_run, 0, MAX_LEVEL + 1);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1999 memset(index_run, rl->n, MAX_RUN + 1);
986e461dc072 Initial revision
glantau
parents:
diff changeset
2000 for(i=start;i<end;i++) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
2001 run = rl->table_run[i];
986e461dc072 Initial revision
glantau
parents:
diff changeset
2002 level = rl->table_level[i];
986e461dc072 Initial revision
glantau
parents:
diff changeset
2003 if (index_run[run] == rl->n)
986e461dc072 Initial revision
glantau
parents:
diff changeset
2004 index_run[run] = i;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2005 if (level > max_level[run])
986e461dc072 Initial revision
glantau
parents:
diff changeset
2006 max_level[run] = level;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2007 if (run > max_run[level])
986e461dc072 Initial revision
glantau
parents:
diff changeset
2008 max_run[level] = run;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2009 }
396
fce0a2520551 removed useless header includes - use av memory functions
glantau
parents: 365
diff changeset
2010 rl->max_level[last] = av_malloc(MAX_RUN + 1);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2011 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
2012 rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2013 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
2014 rl->index_run[last] = av_malloc(MAX_RUN + 1);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2015 memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
986e461dc072 Initial revision
glantau
parents:
diff changeset
2016 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
2017 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
2018
986e461dc072 Initial revision
glantau
parents:
diff changeset
2019 void init_vlc_rl(RLTable *rl)
986e461dc072 Initial revision
glantau
parents:
diff changeset
2020 {
542
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2021 int i, q;
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2022
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2023 init_vlc(&rl->vlc, 9, rl->n + 1,
986e461dc072 Initial revision
glantau
parents:
diff changeset
2024 &rl->table_vlc[0][1], 4, 2,
986e461dc072 Initial revision
glantau
parents:
diff changeset
2025 &rl->table_vlc[0][0], 4, 2);
542
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2026
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2027
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2028 for(q=0; q<32; q++){
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2029 int qmul= q*2;
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2030 int qadd= (q-1)|1;
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2031
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2032 if(q==0){
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2033 qmul=1;
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2034 qadd=0;
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2035 }
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2036
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2037 rl->rl_vlc[q]= av_malloc(rl->vlc.table_size*sizeof(RL_VLC_ELEM));
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2038 for(i=0; i<rl->vlc.table_size; i++){
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2039 int code= rl->vlc.table[i][0];
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2040 int len = rl->vlc.table[i][1];
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2041 int level, run;
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2042
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2043 if(len==0){ // illegal code
563
61442627f857 fixes fire.avi & subtitles.avi
michaelni
parents: 549
diff changeset
2044 run= 66;
542
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2045 level= MAX_LEVEL;
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2046 }else if(len<0){ //more bits needed
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2047 run= 0;
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2048 level= code;
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2049 }else{
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2050 if(code==rl->n){ //esc
563
61442627f857 fixes fire.avi & subtitles.avi
michaelni
parents: 549
diff changeset
2051 run= 66;
542
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2052 level= 0;
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2053 }else{
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2054 run= rl->table_run [code] + 1;
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2055 level= rl->table_level[code] * qmul + qadd;
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2056 if(code >= rl->last) run+=192;
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2057 }
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2058 }
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2059 rl->rl_vlc[q][i].len= len;
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2060 rl->rl_vlc[q][i].level= level;
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2061 rl->rl_vlc[q][i].run= run;
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2062 }
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2063 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2064 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
2065
986e461dc072 Initial revision
glantau
parents:
diff changeset
2066 /* init vlcs */
986e461dc072 Initial revision
glantau
parents:
diff changeset
2067
986e461dc072 Initial revision
glantau
parents:
diff changeset
2068 /* XXX: find a better solution to handle static init */
986e461dc072 Initial revision
glantau
parents:
diff changeset
2069 void h263_decode_init_vlc(MpegEncContext *s)
986e461dc072 Initial revision
glantau
parents:
diff changeset
2070 {
986e461dc072 Initial revision
glantau
parents:
diff changeset
2071 static int done = 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2072
986e461dc072 Initial revision
glantau
parents:
diff changeset
2073 if (!done) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
2074 done = 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2075
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
2076 init_vlc(&intra_MCBPC_vlc, INTRA_MCBPC_VLC_BITS, 8,
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2077 intra_MCBPC_bits, 1, 1,
986e461dc072 Initial revision
glantau
parents:
diff changeset
2078 intra_MCBPC_code, 1, 1);
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
2079 init_vlc(&inter_MCBPC_vlc, INTER_MCBPC_VLC_BITS, 25,
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2080 inter_MCBPC_bits, 1, 1,
986e461dc072 Initial revision
glantau
parents:
diff changeset
2081 inter_MCBPC_code, 1, 1);
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
2082 init_vlc(&cbpy_vlc, CBPY_VLC_BITS, 16,
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2083 &cbpy_tab[0][1], 2, 1,
986e461dc072 Initial revision
glantau
parents:
diff changeset
2084 &cbpy_tab[0][0], 2, 1);
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
2085 init_vlc(&mv_vlc, MV_VLC_BITS, 33,
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2086 &mvtab[0][1], 2, 1,
986e461dc072 Initial revision
glantau
parents:
diff changeset
2087 &mvtab[0][0], 2, 1);
986e461dc072 Initial revision
glantau
parents:
diff changeset
2088 init_rl(&rl_inter);
986e461dc072 Initial revision
glantau
parents:
diff changeset
2089 init_rl(&rl_intra);
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
2090 init_rl(&rl_intra_aic);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2091 init_vlc_rl(&rl_inter);
986e461dc072 Initial revision
glantau
parents:
diff changeset
2092 init_vlc_rl(&rl_intra);
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
2093 init_vlc_rl(&rl_intra_aic);
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
2094 init_vlc(&dc_lum, DC_VLC_BITS, 10 /* 13 */,
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2095 &DCtab_lum[0][1], 2, 1,
986e461dc072 Initial revision
glantau
parents:
diff changeset
2096 &DCtab_lum[0][0], 2, 1);
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
2097 init_vlc(&dc_chrom, DC_VLC_BITS, 10 /* 13 */,
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2098 &DCtab_chrom[0][1], 2, 1,
986e461dc072 Initial revision
glantau
parents:
diff changeset
2099 &DCtab_chrom[0][0], 2, 1);
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
2100 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
2101 &sprite_trajectory_tab[0][1], 4, 2,
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
2102 &sprite_trajectory_tab[0][0], 4, 2);
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
2103 init_vlc(&mb_type_b_vlc, MB_TYPE_B_VLC_BITS, 4,
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2104 &mb_type_b_tab[0][1], 2, 1,
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2105 &mb_type_b_tab[0][0], 2, 1);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2106 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
2107 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
2108
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2109 /**
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2110 * Get the GOB height based on picture height.
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2111 */
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2112 int ff_h263_get_gob_height(MpegEncContext *s){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2113 if (s->height <= 400)
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2114 return 1;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2115 else if (s->height <= 800)
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2116 return 2;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2117 else
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2118 return 4;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2119 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2120
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2121 /**
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2122 * decodes the group of blocks header.
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2123 * @return <0 if an error occured
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2124 */
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2125 static int h263_decode_gob_header(MpegEncContext *s)
162
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
2126 {
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
2127 unsigned int val, gfid;
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2128 int left;
162
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
2129
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
2130 /* Check for GOB Start Code */
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
2131 val = show_bits(&s->gb, 16);
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2132 if(val)
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2133 return -1;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2134
162
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
2135 /* We have a GBSC probably with GSTUFF */
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2136 skip_bits(&s->gb, 16); /* Drop the zeros */
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2137 left= s->gb.size*8 - get_bits_count(&s->gb);
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2138 //MN: we must check the bits left or we might end in a infinite loop (or segfault)
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2139 for(;left>13; left--){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2140 if(get_bits1(&s->gb)) break; /* Seek the '1' bit */
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2141 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2142 if(left<=13)
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2143 return -1;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2144
162
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
2145 #ifdef DEBUG
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2146 fprintf(stderr,"\nGOB Start Code at MB %d\n", (s->mb_y * s->mb_width) + s->mb_x);
162
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
2147 #endif
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2148 s->gob_number = get_bits(&s->gb, 5); /* GN */
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2149 gfid = get_bits(&s->gb, 2); /* GFID */
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2150 s->qscale = get_bits(&s->gb, 5); /* GQUANT */
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2151 if(s->qscale==0)
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2152 return -1;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2153 s->mb_x= 0;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2154 s->mb_y= s->gob_index* s->gob_number;
162
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
2155 #ifdef DEBUG
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2156 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
2157 #endif
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
2158 return 0;
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
2159 }
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
2160
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2161 static inline void memsetw(short *tab, int val, int n)
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2162 {
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2163 int i;
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2164 for(i=0;i<n;i++)
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2165 tab[i] = val;
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2166 }
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2167
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2168 void ff_mpeg4_init_partitions(MpegEncContext *s)
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2169 {
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2170 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
2171 init_put_bits(&s->pb2 , s->pb2_buffer , PB_BUFFER_SIZE, NULL, NULL);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2172 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2173
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2174 void ff_mpeg4_merge_partitions(MpegEncContext *s)
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2175 {
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2176 const int pb2_len = get_bit_count(&s->pb2 );
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2177 const int tex_pb_len= get_bit_count(&s->tex_pb);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2178 const int bits= get_bit_count(&s->pb);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2179
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2180 if(s->pict_type==I_TYPE){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2181 put_bits(&s->pb, 19, DC_MARKER);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2182 s->misc_bits+=19 + pb2_len + bits - s->last_bits;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2183 s->i_tex_bits+= tex_pb_len;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2184 }else{
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2185 put_bits(&s->pb, 17, MOTION_MARKER);
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2186 s->misc_bits+=17 + pb2_len;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2187 s->mv_bits+= bits - s->last_bits;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2188 s->p_tex_bits+= tex_pb_len;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2189 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2190
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2191 flush_put_bits(&s->pb2);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2192 flush_put_bits(&s->tex_pb);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2193
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2194 ff_copy_bits(&s->pb, s->pb2_buffer , pb2_len);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2195 ff_copy_bits(&s->pb, s->tex_pb_buffer, tex_pb_len);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2196 s->last_bits= get_bit_count(&s->pb);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2197 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2198
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2199 int ff_mpeg4_get_video_packet_prefix_length(MpegEncContext *s){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2200 switch(s->pict_type){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2201 case I_TYPE:
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2202 return 16;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2203 case P_TYPE:
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2204 case S_TYPE:
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2205 return s->f_code+15;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2206 case B_TYPE:
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2207 return MAX(MAX(s->f_code, s->b_code)+15, 17);
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2208 default:
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2209 return -1;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2210 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2211 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2212
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2213 void ff_mpeg4_encode_video_packet_header(MpegEncContext *s)
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2214 {
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2215 int mb_num_bits= av_log2(s->mb_num - 1) + 1;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2216
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2217 ff_mpeg4_stuffing(&s->pb);
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2218 put_bits(&s->pb, ff_mpeg4_get_video_packet_prefix_length(s), 0);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2219 put_bits(&s->pb, 1, 1);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2220
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2221 put_bits(&s->pb, mb_num_bits, s->mb_x + s->mb_y*s->mb_width);
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2222 put_bits(&s->pb, s->quant_precision, s->qscale);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2223 put_bits(&s->pb, 1, 0); /* no HEC */
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2224 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2225
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2226 /**
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2227 * check if the next stuff is a resync marker or the end.
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2228 * @return 0 if not
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2229 */
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2230 static inline int mpeg4_is_resync(MpegEncContext *s){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2231 const int bits_count= get_bits_count(&s->gb);
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2232
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2233 if(s->workaround_bugs&FF_BUG_NO_PADDING){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2234 return 0;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2235 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2236
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2237 if(bits_count + 8 >= s->gb.size*8){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2238 int v= show_bits(&s->gb, 8);
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2239 v|= 0x7F >> (7-(bits_count&7));
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2240
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2241 if(v==0x7F)
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2242 return 1;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2243 }else{
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2244 if(show_bits(&s->gb, 16) == ff_mpeg4_resync_prefix[bits_count&7]){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2245 int len;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2246 GetBitContext gb= s->gb;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2247
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2248 skip_bits(&s->gb, 1);
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2249 align_get_bits(&s->gb);
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2250
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2251 for(len=0; len<32; len++){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2252 if(get_bits1(&s->gb)) break;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2253 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2254
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2255 s->gb= gb;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2256
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2257 if(len>=ff_mpeg4_get_video_packet_prefix_length(s))
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2258 return 1;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2259 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2260 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2261 return 0;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2262 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2263
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2264 /**
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2265 * decodes the next video packet.
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2266 * @return <0 if something went wrong
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2267 */
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2268 static int mpeg4_decode_video_packet_header(MpegEncContext *s)
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2269 {
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2270 int mb_num_bits= av_log2(s->mb_num - 1) + 1;
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2271 int header_extension=0, mb_num, len;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2272
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2273 /* is there enough space left for a video packet + header */
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2274 if( get_bits_count(&s->gb) > s->gb.size*8-20) return -1;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2275
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2276 for(len=0; len<32; len++){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2277 if(get_bits1(&s->gb)) break;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2278 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2279
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2280 if(len!=ff_mpeg4_get_video_packet_prefix_length(s)){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2281 printf("marker does not match f_code\n");
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2282 return -1;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2283 }
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2284
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2285 if(s->shape != RECT_SHAPE){
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2286 header_extension= get_bits1(&s->gb);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2287 //FIXME more stuff here
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2288 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2289
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2290 mb_num= get_bits(&s->gb, mb_num_bits);
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2291 if(mb_num>=s->mb_num){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2292 fprintf(stderr, "illegal mb_num in video packet (%d %d) \n", mb_num, s->mb_num);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2293 return -1;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2294 }
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2295 s->mb_x= mb_num % s->mb_width;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2296 s->mb_y= mb_num / s->mb_width;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2297
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2298 if(s->shape != BIN_ONLY_SHAPE){
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2299 int qscale= get_bits(&s->gb, s->quant_precision);
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2300 if(qscale)
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2301 s->qscale= qscale;
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2302 }
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2303
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2304 if(s->shape == RECT_SHAPE){
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2305 header_extension= get_bits1(&s->gb);
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2306 }
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2307 if(header_extension){
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2308 int time_increment;
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2309 int time_incr=0;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2310
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2311 while (get_bits1(&s->gb) != 0)
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2312 time_incr++;
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2313
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2314 check_marker(&s->gb, "before time_increment in video packed header");
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2315 time_increment= get_bits(&s->gb, s->time_increment_bits);
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2316 check_marker(&s->gb, "before vop_coding_type in video packed header");
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2317
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2318 skip_bits(&s->gb, 2); /* vop coding type */
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2319 //FIXME not rect stuff here
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2320
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2321 if(s->shape != BIN_ONLY_SHAPE){
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2322 skip_bits(&s->gb, 3); /* intra dc vlc threshold */
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2323 //FIXME dont just ignore everything
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2324 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
2325 mpeg4_decode_sprite_trajectory(s);
660
b8e268337a1d parsing resync header extension support
michaelni
parents: 659
diff changeset
2326 fprintf(stderr, "untested\n");
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2327 }
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2328
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2329 //FIXME reduced res stuff here
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2330
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2331 if (s->pict_type != I_TYPE) {
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2332 int f_code = get_bits(&s->gb, 3); /* fcode_for */
660
b8e268337a1d parsing resync header extension support
michaelni
parents: 659
diff changeset
2333 if(f_code==0){
b8e268337a1d parsing resync header extension support
michaelni
parents: 659
diff changeset
2334 printf("Error, video packet header damaged (f_code=0)\n");
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2335 }
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2336 }
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2337 if (s->pict_type == B_TYPE) {
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2338 int b_code = get_bits(&s->gb, 3);
660
b8e268337a1d parsing resync header extension support
michaelni
parents: 659
diff changeset
2339 if(b_code==0){
b8e268337a1d parsing resync header extension support
michaelni
parents: 659
diff changeset
2340 printf("Error, video packet header damaged (b_code=0)\n");
b8e268337a1d parsing resync header extension support
michaelni
parents: 659
diff changeset
2341 }
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2342 }
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2343 }
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2344 }
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2345 //FIXME new-pred stuff
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2346
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2347 //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
2348
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2349 return 0;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2350 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2351
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2352 void ff_mpeg4_clean_buffers(MpegEncContext *s)
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2353 {
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2354 int c_wrap, c_xy, l_wrap, l_xy;
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2355
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2356 l_wrap= s->block_wrap[0];
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2357 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
2358 c_wrap= s->block_wrap[4];
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2359 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
2360
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2361 #if 0
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2362 /* clean DC */
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2363 memsetw(s->dc_val[0] + l_xy, 1024, l_wrap*2+1);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2364 memsetw(s->dc_val[1] + c_xy, 1024, c_wrap+1);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2365 memsetw(s->dc_val[2] + c_xy, 1024, c_wrap+1);
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2366 #endif
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2367
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2368 /* clean AC */
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2369 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
2370 memset(s->ac_val[1] + c_xy, 0, (c_wrap +1)*16*sizeof(INT16));
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2371 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
2372
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2373 /* clean MV */
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2374 // we cant clear the MVs as they might be needed by a b frame
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2375 // 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
2376 // 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
2377 s->last_mv[0][0][0]=
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2378 s->last_mv[0][0][1]=
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2379 s->last_mv[1][0][0]=
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2380 s->last_mv[1][0][1]= 0;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2381 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2382
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2383 /**
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2384 * decodes the group of blocks / video packet header.
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2385 * @return <0 if no resync found
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2386 */
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2387 int ff_h263_resync(MpegEncContext *s){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2388 int left, ret;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2389
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2390 if(s->codec_id==CODEC_ID_MPEG4)
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2391 skip_bits1(&s->gb);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2392
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2393 align_get_bits(&s->gb);
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2394
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2395 if(show_bits(&s->gb, 16)==0){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2396 if(s->codec_id==CODEC_ID_MPEG4)
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2397 ret= mpeg4_decode_video_packet_header(s);
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2398 else
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2399 ret= h263_decode_gob_header(s);
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2400 if(ret>=0)
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2401 return 0;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2402 }
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2403 //ok, its not where its supposed to be ...
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2404 s->gb= s->last_resync_gb;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2405 align_get_bits(&s->gb);
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2406 left= s->gb.size*8 - get_bits_count(&s->gb);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2407
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2408 for(;left>16+1+5+5; left-=8){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2409 if(show_bits(&s->gb, 16)==0){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2410 GetBitContext bak= s->gb;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2411
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2412 if(s->codec_id==CODEC_ID_MPEG4)
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2413 ret= mpeg4_decode_video_packet_header(s);
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2414 else
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2415 ret= h263_decode_gob_header(s);
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2416 if(ret>=0)
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2417 return 0;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2418
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2419 s->gb= bak;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2420 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2421 skip_bits(&s->gb, 8);
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2422 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2423
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2424 return -1;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2425 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2426
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2427 /**
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2428 * @param n either 0 for the x component or 1 for y
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2429 * @returns the average MV for a GMC MB
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2430 */
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2431 static inline int get_amv(MpegEncContext *s, int n){
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2432 int x, y, mb_v, sum, dx, dy, shift;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2433 int len = 1 << (s->f_code + 4);
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2434 const int a= s->sprite_warping_accuracy;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2435
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2436 if(s->real_sprite_warping_points==1){
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2437 if(s->divx_version==500 && s->divx_build==413)
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2438 sum= s->sprite_offset[0][n] / (1<<(a - s->quarter_sample));
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2439 else
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2440 sum= RSHIFT(s->sprite_offset[0][n]<<s->quarter_sample, a);
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2441 }else{
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2442 dx= s->sprite_delta[n][0];
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2443 dy= s->sprite_delta[n][1];
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2444 shift= s->sprite_shift[0];
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2445 if(n) dy -= 1<<(shift + a + 1);
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2446 else dx -= 1<<(shift + a + 1);
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2447 mb_v= s->sprite_offset[0][n] + dx*s->mb_x*16 + dy*s->mb_y*16;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2448
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2449 sum=0;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2450 for(y=0; y<16; y++){
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2451 int v;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2452
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2453 v= mb_v + dy*y;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2454 //XXX FIXME optimize
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2455 for(x=0; x<16; x++){
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2456 sum+= v>>shift;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2457 v+= dx;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2458 }
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2459 }
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2460 sum /= 256;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2461 sum= RSHIFT(sum<<s->quarter_sample, a);
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2462 }
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2463
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2464 if (sum < -len) sum= -len;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2465 else if (sum >= len) sum= len-1;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2466
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2467 return sum;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2468 }
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2469
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2470 /**
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2471 * decodes first partition.
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2472 * @return number of MBs decoded or <0 if an error occured
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2473 */
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2474 static int mpeg4_decode_partition_a(MpegEncContext *s){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2475 int mb_num;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2476 static const INT8 quant_tab[4] = { -1, -2, 1, 2 };
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2477
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2478 /* decode first partition */
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2479 mb_num=0;
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2480 s->first_slice_line=1;
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2481 for(; s->mb_y<s->mb_height; s->mb_y++){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2482 ff_init_block_index(s);
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2483 for(; s->mb_x<s->mb_width; s->mb_x++){
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2484 const int xy= s->mb_x + s->mb_y*s->mb_width;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2485 int cbpc;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2486 int dir=0;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2487
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2488 mb_num++;
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2489 ff_update_block_index(s);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2490 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
2491 s->first_slice_line=0;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2492
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2493 if(s->mb_x==0) PRINT_MB_TYPE("\n");
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2494
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2495 if(s->pict_type==I_TYPE){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2496 int i;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2497
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2498 if(show_bits(&s->gb, 19)==DC_MARKER){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2499 return mb_num-1;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2500 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2501
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2502 PRINT_MB_TYPE("I");
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
2503 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
2504 if (cbpc < 0){
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2505
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2506 fprintf(stderr, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2507 return -1;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2508 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2509 s->cbp_table[xy]= cbpc & 3;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2510 s->mb_type[xy]= MB_TYPE_INTRA;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2511 s->mb_intra = 1;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2512
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2513 if(cbpc & 4) {
698
e050a053e259 h263_dc_scale() cleanup
michaelni
parents: 697
diff changeset
2514 change_qscale(s, quant_tab[get_bits(&s->gb, 2)]);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2515 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2516 s->qscale_table[xy]= s->qscale;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2517
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2518 s->mbintra_table[xy]= 1;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2519 for(i=0; i<6; i++){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2520 int dc_pred_dir;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2521 int dc= mpeg4_decode_dc(s, i, &dc_pred_dir);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2522 if(dc < 0){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2523 fprintf(stderr, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2524 return -1;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2525 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2526 dir<<=1;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2527 if(dc_pred_dir) dir|=1;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2528 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2529 s->pred_dir_table[xy]= dir;
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2530
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2531 s->error_status_table[xy]= AC_ERROR;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2532 }else{ /* P/S_TYPE */
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2533 int mx, my, pred_x, pred_y, bits;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2534 INT16 * const mot_val= s->motion_val[s->block_index[0]];
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2535 const int stride= s->block_wrap[0]*2;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2536
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2537 bits= show_bits(&s->gb, 17);
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2538 if(bits==MOTION_MARKER){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2539 return mb_num-1;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2540 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2541 skip_bits1(&s->gb);
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2542 if(bits&0x10000){
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2543 /* skip mb */
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2544 s->mb_type[xy]= MB_TYPE_SKIPED;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2545 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2546 PRINT_MB_TYPE("G");
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2547 mx= get_amv(s, 0);
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2548 my= get_amv(s, 1);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2549 }else{
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2550 PRINT_MB_TYPE("S");
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2551 mx=my=0;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2552 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2553 mot_val[0 ]= mot_val[2 ]=
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2554 mot_val[0+stride]= mot_val[2+stride]= mx;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2555 mot_val[1 ]= mot_val[3 ]=
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2556 mot_val[1+stride]= mot_val[3+stride]= my;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2557
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2558 if(s->mbintra_table[xy])
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2559 ff_clean_intra_table_entries(s);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2560
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2561 s->error_status_table[xy]= AC_ERROR;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2562 continue;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2563 }
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
2564 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
2565 if (cbpc < 0){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2566 fprintf(stderr, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2567 return -1;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2568 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2569 if (cbpc > 20)
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2570 cbpc+=3;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2571 else if (cbpc == 20)
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2572 fprintf(stderr, "Stuffing !");
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2573 s->cbp_table[xy]= cbpc&(8+3); //8 is dquant
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2574
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2575 s->mb_intra = ((cbpc & 4) != 0);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2576
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2577 if(s->mb_intra){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2578 PRINT_MB_TYPE("I");
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2579 s->mbintra_table[xy]= 1;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2580 s->mb_type[xy]= MB_TYPE_INTRA;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2581 mot_val[0 ]= mot_val[2 ]=
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2582 mot_val[0+stride]= mot_val[2+stride]= 0;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2583 mot_val[1 ]= mot_val[3 ]=
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2584 mot_val[1+stride]= mot_val[3+stride]= 0;
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2585 s->error_status_table[xy]= DC_ERROR|AC_ERROR;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2586 }else{
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2587 if(s->mbintra_table[xy])
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2588 ff_clean_intra_table_entries(s);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2589
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2590 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
2591 s->mcsel= get_bits1(&s->gb);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2592 else s->mcsel= 0;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2593
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2594 if ((cbpc & 16) == 0) {
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2595 PRINT_MB_TYPE("P");
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2596 /* 16x16 motion prediction */
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2597 s->mb_type[xy]= MB_TYPE_INTER;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2598
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2599 h263_pred_motion(s, 0, &pred_x, &pred_y);
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2600 if(!s->mcsel){
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2601 mx = h263_decode_motion(s, pred_x, s->f_code);
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2602 if (mx >= 0xffff)
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2603 return -1;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2604
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2605 my = h263_decode_motion(s, pred_y, s->f_code);
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2606 if (my >= 0xffff)
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2607 return -1;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2608 } else {
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2609 mx = get_amv(s, 0);
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2610 my = get_amv(s, 1);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2611 }
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2612
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2613 mot_val[0 ]= mot_val[2 ] =
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2614 mot_val[0+stride]= mot_val[2+stride]= mx;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2615 mot_val[1 ]= mot_val[3 ]=
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2616 mot_val[1+stride]= mot_val[3+stride]= my;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2617 } else {
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2618 int i;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2619 PRINT_MB_TYPE("4");
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2620 s->mb_type[xy]= MB_TYPE_INTER4V;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2621 for(i=0;i<4;i++) {
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2622 INT16 *mot_val= h263_pred_motion(s, i, &pred_x, &pred_y);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2623 mx = h263_decode_motion(s, pred_x, s->f_code);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2624 if (mx >= 0xffff)
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2625 return -1;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2626
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2627 my = h263_decode_motion(s, pred_y, s->f_code);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2628 if (my >= 0xffff)
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2629 return -1;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2630 mot_val[0] = mx;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2631 mot_val[1] = my;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2632 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2633 }
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2634 s->error_status_table[xy]= AC_ERROR;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2635 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2636 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2637 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2638 s->mb_x= 0;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2639 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2640
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2641 return mb_num;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2642 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2643
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2644 /**
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2645 * decode second partition.
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2646 * @return <0 if an error occured
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2647 */
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2648 static int mpeg4_decode_partition_b(MpegEncContext *s, int mb_count){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2649 int mb_num=0;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2650 static const INT8 quant_tab[4] = { -1, -2, 1, 2 };
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2651
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2652 s->mb_x= s->resync_mb_x;
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2653 s->first_slice_line=1;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2654 for(s->mb_y= s->resync_mb_y; mb_num < mb_count; s->mb_y++){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2655 ff_init_block_index(s);
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2656 for(; mb_num < mb_count && s->mb_x<s->mb_width; s->mb_x++){
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2657 const int xy= s->mb_x + s->mb_y*s->mb_width;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2658
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2659 mb_num++;
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2660 ff_update_block_index(s);
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2661 if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2662 s->first_slice_line=0;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2663
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2664 if(s->pict_type==I_TYPE){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2665 int ac_pred= get_bits1(&s->gb);
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
2666 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2667 if(cbpy<0){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2668 fprintf(stderr, "cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2669 return -1;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2670 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2671
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2672 s->cbp_table[xy]|= cbpy<<2;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2673 s->pred_dir_table[xy]|= ac_pred<<7;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2674 }else{ /* P || S_TYPE */
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2675 if(s->mb_type[xy]&MB_TYPE_INTRA){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2676 int dir=0,i;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2677 int ac_pred = get_bits1(&s->gb);
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
2678 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2679
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2680 if(cbpy<0){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2681 fprintf(stderr, "I cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2682 return -1;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2683 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2684
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2685 if(s->cbp_table[xy] & 8) {
698
e050a053e259 h263_dc_scale() cleanup
michaelni
parents: 697
diff changeset
2686 change_qscale(s, quant_tab[get_bits(&s->gb, 2)]);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2687 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2688 s->qscale_table[xy]= s->qscale;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2689
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2690 for(i=0; i<6; i++){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2691 int dc_pred_dir;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2692 int dc= mpeg4_decode_dc(s, i, &dc_pred_dir);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2693 if(dc < 0){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2694 fprintf(stderr, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2695 return -1;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2696 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2697 dir<<=1;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2698 if(dc_pred_dir) dir|=1;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2699 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2700 s->cbp_table[xy]&= 3; //remove dquant
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2701 s->cbp_table[xy]|= cbpy<<2;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2702 s->pred_dir_table[xy]= dir | (ac_pred<<7);
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2703 s->error_status_table[xy]&= ~DC_ERROR;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2704 }else if(s->mb_type[xy]&MB_TYPE_SKIPED){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2705 s->qscale_table[xy]= s->qscale;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2706 s->cbp_table[xy]= 0;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2707 }else{
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
2708 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2709
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2710 if(cbpy<0){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2711 fprintf(stderr, "P cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2712 return -1;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2713 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2714
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2715 if(s->cbp_table[xy] & 8) {
698
e050a053e259 h263_dc_scale() cleanup
michaelni
parents: 697
diff changeset
2716 change_qscale(s, quant_tab[get_bits(&s->gb, 2)]);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2717 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2718 s->qscale_table[xy]= s->qscale;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2719
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2720 s->cbp_table[xy]&= 3; //remove dquant
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2721 s->cbp_table[xy]|= (cbpy^0xf)<<2;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2722 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2723 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2724 }
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2725 if(mb_num >= mb_count) return 0;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2726 s->mb_x= 0;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2727 }
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2728 return 0;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2729 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2730
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2731 /**
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2732 * decodes the first & second partition
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2733 * @return <0 if error (and sets error type in the error_status_table)
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2734 */
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2735 int ff_mpeg4_decode_partitions(MpegEncContext *s)
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2736 {
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2737 int mb_num;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2738
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2739 mb_num= mpeg4_decode_partition_a(s);
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2740 if(mb_num<0)
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2741 return -1;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2742
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2743 if(s->resync_mb_x + s->resync_mb_y*s->mb_width + mb_num > s->mb_num){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2744 fprintf(stderr, "slice below monitor ...\n");
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2745 return -1;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2746 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2747
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2748 s->mb_num_left= mb_num;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2749
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2750 if(s->pict_type==I_TYPE){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2751 if(get_bits(&s->gb, 19)!=DC_MARKER){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2752 fprintf(stderr, "marker missing after first I partition at %d %d\n", s->mb_x, s->mb_y);
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2753 return -1;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2754 }else
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2755 s->error_status_table[s->mb_x + s->mb_y*s->mb_width-1]|= MV_END|DC_END;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2756 }else{
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2757 if(get_bits(&s->gb, 17)!=MOTION_MARKER){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2758 fprintf(stderr, "marker missing after first P partition at %d %d\n", s->mb_x, s->mb_y);
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2759 return -1;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2760 }else
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2761 s->error_status_table[s->mb_x + s->mb_y*s->mb_width-1]|= MV_END;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2762 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2763
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2764 if( mpeg4_decode_partition_b(s, mb_num) < 0){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2765 return -1;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2766 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2767
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2768 s->error_status_table[s->mb_x + s->mb_y*s->mb_width-1]|= DC_END;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2769
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2770 return 0;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2771 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2772
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2773 /**
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2774 * decode partition C of one MB.
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2775 * @return <0 if an error occured
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2776 */
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2777 static int mpeg4_decode_partitioned_mb(MpegEncContext *s, DCTELEM block[6][64])
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2778 {
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2779 int cbp, mb_type;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2780 const int xy= s->mb_x + s->mb_y*s->mb_width;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2781
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2782 mb_type= s->mb_type[xy];
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2783 cbp = s->cbp_table[xy];
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2784
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2785 if(s->qscale_table[xy] != s->qscale){
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2786 s->qscale= s->qscale_table[xy];
698
e050a053e259 h263_dc_scale() cleanup
michaelni
parents: 697
diff changeset
2787 s->y_dc_scale= s->y_dc_scale_table[ s->qscale ];
e050a053e259 h263_dc_scale() cleanup
michaelni
parents: 697
diff changeset
2788 s->c_dc_scale= s->c_dc_scale_table[ s->qscale ];
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2789 }
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2790
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2791 if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2792 int i;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2793 for(i=0; i<4; i++){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2794 s->mv[0][i][0] = s->motion_val[ s->block_index[i] ][0];
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2795 s->mv[0][i][1] = s->motion_val[ s->block_index[i] ][1];
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2796 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2797 s->mb_intra = mb_type&MB_TYPE_INTRA;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2798
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2799 if (mb_type&MB_TYPE_SKIPED) {
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2800 /* skip mb */
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2801 for(i=0;i<6;i++)
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2802 s->block_last_index[i] = -1;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2803 s->mv_dir = MV_DIR_FORWARD;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2804 s->mv_type = MV_TYPE_16X16;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2805 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2806 s->mcsel=1;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2807 s->mb_skiped = 0;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2808 }else{
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2809 s->mcsel=0;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2810 s->mb_skiped = 1;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2811 }
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2812 }else if(s->mb_intra){
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2813 s->ac_pred = s->pred_dir_table[xy]>>7;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2814
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2815 /* decode each block */
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2816 for (i = 0; i < 6; i++) {
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2817 if(mpeg4_decode_block(s, block[i], i, cbp&32, 1) < 0){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2818 fprintf(stderr, "texture corrupted at %d %d\n", s->mb_x, s->mb_y);
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2819 return -1;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2820 }
718
16dab8296293 fixing custom quantizer matrix decoding
michaelni
parents: 706
diff changeset
2821 cbp+=cbp;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2822 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2823 }else if(!s->mb_intra){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2824 // s->mcsel= 0; //FIXME do we need to init that
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2825
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2826 s->mv_dir = MV_DIR_FORWARD;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2827 if (mb_type&MB_TYPE_INTER4V) {
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2828 s->mv_type = MV_TYPE_8X8;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2829 } else {
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2830 s->mv_type = MV_TYPE_16X16;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2831 }
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2832 /* decode each block */
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2833 for (i = 0; i < 6; i++) {
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2834 if(mpeg4_decode_block(s, block[i], i, cbp&32, 0) < 0){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2835 fprintf(stderr, "texture corrupted at %d %d (trying to continue with mc/dc only)\n", s->mb_x, s->mb_y);
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2836 return -1;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2837 }
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2838 cbp+=cbp;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2839 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2840 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2841 } else { /* I-Frame */
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2842 int i;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2843 s->mb_intra = 1;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2844 s->ac_pred = s->pred_dir_table[xy]>>7;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2845
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2846 /* decode each block */
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2847 for (i = 0; i < 6; i++) {
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2848 if(mpeg4_decode_block(s, block[i], i, cbp&32, 1) < 0){
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2849 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
2850 return -1;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2851 }
718
16dab8296293 fixing custom quantizer matrix decoding
michaelni
parents: 706
diff changeset
2852 cbp+=cbp;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2853 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2854 }
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2855
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2856 s->error_status_table[xy]&= ~AC_ERROR;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2857
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2858 /* per-MB end of slice check */
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2859
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2860 if(--s->mb_num_left <= 0){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2861 //printf("%06X %d\n", show_bits(&s->gb, 24), s->gb.size*8 - get_bits_count(&s->gb));
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2862 if(mpeg4_is_resync(s))
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2863 return SLICE_END;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2864 else
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2865 return SLICE_NOEND;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2866 }else{
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2867 if(s->cbp_table[xy+1] && mpeg4_is_resync(s))
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2868 return SLICE_END;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2869 else
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2870 return SLICE_OK;
619
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
2871 }
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
2872 }
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2873
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2874 int ff_h263_decode_mb(MpegEncContext *s,
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2875 DCTELEM block[6][64])
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2876 {
986e461dc072 Initial revision
glantau
parents:
diff changeset
2877 int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2878 INT16 *mot_val;
110
e00e5d93457c Added Juergen Keil fix on quant_tab[4] type.
pulento
parents: 79
diff changeset
2879 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
2880
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2881 s->error_status_table[s->mb_x + s->mb_y*s->mb_width]= 0;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2882
523
c7e4c8b9a3c4 warning fix patch by atmos
michaelni
parents: 498
diff changeset
2883 if(s->mb_x==0) PRINT_MB_TYPE("\n");
359
df0736462b9f move ABS() to common.h
michaelni
parents: 358
diff changeset
2884
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
2885 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
2886 if (get_bits1(&s->gb)) {
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2887 /* skip mb */
986e461dc072 Initial revision
glantau
parents:
diff changeset
2888 s->mb_intra = 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2889 for(i=0;i<6;i++)
986e461dc072 Initial revision
glantau
parents:
diff changeset
2890 s->block_last_index[i] = -1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2891 s->mv_dir = MV_DIR_FORWARD;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2892 s->mv_type = MV_TYPE_16X16;
255
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
2893 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
359
df0736462b9f move ABS() to common.h
michaelni
parents: 358
diff changeset
2894 PRINT_MB_TYPE("G");
255
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
2895 s->mcsel=1;
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2896 s->mv[0][0][0]= get_amv(s, 0);
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2897 s->mv[0][0][1]= get_amv(s, 1);
255
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
2898
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
2899 s->mb_skiped = 0;
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
2900 }else{
359
df0736462b9f move ABS() to common.h
michaelni
parents: 358
diff changeset
2901 PRINT_MB_TYPE("S");
255
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
2902 s->mcsel=0;
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
2903 s->mv[0][0][0] = 0;
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
2904 s->mv[0][0][1] = 0;
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
2905 s->mb_skiped = 1;
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
2906 }
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2907 goto end;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2908 }
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
2909 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
2910 //fprintf(stderr, "\tCBPC: %d", cbpc);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2911 if (cbpc < 0)
986e461dc072 Initial revision
glantau
parents:
diff changeset
2912 return -1;
161
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
2913 if (cbpc > 20)
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
2914 cbpc+=3;
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
2915 else if (cbpc == 20)
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
2916 fprintf(stderr, "Stuffing !");
144
cb5dabd00ba2 - Bug fix on inter MCBPC table for inter+q.
pulento
parents: 110
diff changeset
2917
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2918 dquant = cbpc & 8;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2919 s->mb_intra = ((cbpc & 4) != 0);
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2920 if (s->mb_intra) goto intra;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2921
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
2922 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
2923 s->mcsel= get_bits1(&s->gb);
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
2924 else s->mcsel= 0;
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
2925 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2926 cbp = (cbpc & 3) | ((cbpy ^ 0xf) << 2);
986e461dc072 Initial revision
glantau
parents:
diff changeset
2927 if (dquant) {
698
e050a053e259 h263_dc_scale() cleanup
michaelni
parents: 697
diff changeset
2928 change_qscale(s, quant_tab[get_bits(&s->gb, 2)]);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2929 }
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2930 if((!s->progressive_sequence) && (cbp || (s->workaround_bugs&FF_BUG_XVID_ILACE)))
619
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
2931 s->interlaced_dct= get_bits1(&s->gb);
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
2932
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2933 s->mv_dir = MV_DIR_FORWARD;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2934 if ((cbpc & 16) == 0) {
619
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
2935 if(s->mcsel){
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
2936 PRINT_MB_TYPE("G");
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
2937 /* 16x16 global motion prediction */
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
2938 s->mv_type = MV_TYPE_16X16;
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2939 mx= get_amv(s, 0);
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2940 my= get_amv(s, 1);
619
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
2941 s->mv[0][0][0] = mx;
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
2942 s->mv[0][0][1] = my;
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
2943 }else if((!s->progressive_sequence) && get_bits1(&s->gb)){
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
2944 PRINT_MB_TYPE("f");
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
2945 /* 16x8 field motion prediction */
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
2946 s->mv_type= MV_TYPE_FIELD;
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
2947
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
2948 s->field_select[0][0]= get_bits1(&s->gb);
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
2949 s->field_select[0][1]= get_bits1(&s->gb);
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
2950
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
2951 h263_pred_motion(s, 0, &pred_x, &pred_y);
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
2952
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
2953 for(i=0; i<2; i++){
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
2954 mx = h263_decode_motion(s, pred_x, s->f_code);
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
2955 if (mx >= 0xffff)
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
2956 return -1;
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
2957
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
2958 my = h263_decode_motion(s, pred_y/2, s->f_code);
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
2959 if (my >= 0xffff)
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
2960 return -1;
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
2961
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
2962 s->mv[0][i][0] = mx;
661
a0901e38c564 fixing interlaced mpeg4 decoding
michaelni
parents: 660
diff changeset
2963 s->mv[0][i][1] = my;
619
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
2964 }
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
2965 }else{
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
2966 PRINT_MB_TYPE("P");
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
2967 /* 16x16 motion prediction */
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
2968 s->mv_type = MV_TYPE_16X16;
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
2969 h263_pred_motion(s, 0, &pred_x, &pred_y);
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
2970 if (s->umvplus_dec)
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
2971 mx = h263p_decode_umotion(s, pred_x);
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
2972 else
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
2973 mx = h263_decode_motion(s, pred_x, s->f_code);
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
2974
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
2975 if (mx >= 0xffff)
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
2976 return -1;
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
2977
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
2978 if (s->umvplus_dec)
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
2979 my = h263p_decode_umotion(s, pred_y);
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
2980 else
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
2981 my = h263_decode_motion(s, pred_y, s->f_code);
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
2982
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
2983 if (my >= 0xffff)
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
2984 return -1;
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
2985 s->mv[0][0][0] = mx;
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
2986 s->mv[0][0][1] = my;
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
2987
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
2988 if (s->umvplus_dec && (mx - pred_x) == 1 && (my - pred_y) == 1)
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
2989 skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
255
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
2990 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2991 } else {
359
df0736462b9f move ABS() to common.h
michaelni
parents: 358
diff changeset
2992 PRINT_MB_TYPE("4");
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2993 s->mv_type = MV_TYPE_8X8;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2994 for(i=0;i<4;i++) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
2995 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
2996 if (s->umvplus_dec)
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
2997 mx = h263p_decode_umotion(s, pred_x);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
2998 else
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2999 mx = h263_decode_motion(s, pred_x, s->f_code);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3000 if (mx >= 0xffff)
986e461dc072 Initial revision
glantau
parents:
diff changeset
3001 return -1;
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3002
79
82e579c37bc3 Moved some H.263+ variables to MpegEncContext to be thread-safe.
pulento
parents: 78
diff changeset
3003 if (s->umvplus_dec)
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3004 my = h263p_decode_umotion(s, pred_y);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3005 else
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3006 my = h263_decode_motion(s, pred_y, s->f_code);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3007 if (my >= 0xffff)
986e461dc072 Initial revision
glantau
parents:
diff changeset
3008 return -1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3009 s->mv[0][i][0] = mx;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3010 s->mv[0][i][1] = my;
79
82e579c37bc3 Moved some H.263+ variables to MpegEncContext to be thread-safe.
pulento
parents: 78
diff changeset
3011 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
3012 skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3013 mot_val[0] = mx;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3014 mot_val[1] = my;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3015 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
3016 }
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3017 } else if(s->pict_type==B_TYPE) {
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3018 int modb1; // first bit of modb
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3019 int modb2; // second bit of modb
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3020 int mb_type;
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
3021 uint16_t time_pp;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
3022 uint16_t time_pb;
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3023 int xy;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3024
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3025 s->mb_intra = 0; //B-frames never contain intra blocks
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3026 s->mcsel=0; // ... true gmc blocks
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3027
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3028 if(s->mb_x==0){
674
4490bfbb932d interlaced b frames fix
michaelni
parents: 669
diff changeset
3029 for(i=0; i<2; i++){
4490bfbb932d interlaced b frames fix
michaelni
parents: 669
diff changeset
3030 s->last_mv[i][0][0]=
4490bfbb932d interlaced b frames fix
michaelni
parents: 669
diff changeset
3031 s->last_mv[i][0][1]=
4490bfbb932d interlaced b frames fix
michaelni
parents: 669
diff changeset
3032 s->last_mv[i][1][0]=
4490bfbb932d interlaced b frames fix
michaelni
parents: 669
diff changeset
3033 s->last_mv[i][1][1]= 0;
4490bfbb932d interlaced b frames fix
michaelni
parents: 669
diff changeset
3034 }
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3035 }
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3036
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3037 /* if we skipped it in the future P Frame than skip it now too */
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3038 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
3039
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3040 if(s->mb_skiped){
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3041 /* skip mb */
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3042 for(i=0;i<6;i++)
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3043 s->block_last_index[i] = -1;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3044
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3045 s->mv_dir = MV_DIR_FORWARD;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3046 s->mv_type = MV_TYPE_16X16;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3047 s->mv[0][0][0] = 0;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3048 s->mv[0][0][1] = 0;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3049 s->mv[1][0][0] = 0;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3050 s->mv[1][0][1] = 0;
523
c7e4c8b9a3c4 warning fix patch by atmos
michaelni
parents: 498
diff changeset
3051 PRINT_MB_TYPE("s");
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3052 goto end;
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3053 }
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3054
666
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3055 modb1= get_bits1(&s->gb);
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3056 if(modb1){
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3057 mb_type=4; //like MB_TYPE_B_DIRECT but no vectors coded
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3058 cbp=0;
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3059 }else{
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3060 int field_mv;
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3061
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3062 modb2= get_bits1(&s->gb);
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
3063 mb_type= get_vlc2(&s->gb, mb_type_b_vlc.table, MB_TYPE_B_VLC_BITS, 1);
666
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3064 if(modb2) cbp= 0;
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3065 else cbp= get_bits(&s->gb, 6);
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3066
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3067 if (mb_type!=MB_TYPE_B_DIRECT && cbp) {
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3068 if(get_bits1(&s->gb)){
698
e050a053e259 h263_dc_scale() cleanup
michaelni
parents: 697
diff changeset
3069 change_qscale(s, get_bits1(&s->gb)*4 - 2);
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3070 }
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3071 }
666
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3072 field_mv=0;
664
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
3073
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
3074 if(!s->progressive_sequence){
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
3075 if(cbp)
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
3076 s->interlaced_dct= get_bits1(&s->gb);
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
3077
667
5446a41a00fe 10l (field select readed at the wrong place ...)
michaelni
parents: 666
diff changeset
3078 if(mb_type!=MB_TYPE_B_DIRECT && get_bits1(&s->gb)){
666
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3079 field_mv=1;
667
5446a41a00fe 10l (field select readed at the wrong place ...)
michaelni
parents: 666
diff changeset
3080
5446a41a00fe 10l (field select readed at the wrong place ...)
michaelni
parents: 666
diff changeset
3081 if(mb_type!=MB_TYPE_B_BACKW){
5446a41a00fe 10l (field select readed at the wrong place ...)
michaelni
parents: 666
diff changeset
3082 s->field_select[0][0]= get_bits1(&s->gb);
5446a41a00fe 10l (field select readed at the wrong place ...)
michaelni
parents: 666
diff changeset
3083 s->field_select[0][1]= get_bits1(&s->gb);
5446a41a00fe 10l (field select readed at the wrong place ...)
michaelni
parents: 666
diff changeset
3084 }
5446a41a00fe 10l (field select readed at the wrong place ...)
michaelni
parents: 666
diff changeset
3085 if(mb_type!=MB_TYPE_B_FORW){
5446a41a00fe 10l (field select readed at the wrong place ...)
michaelni
parents: 666
diff changeset
3086 s->field_select[1][0]= get_bits1(&s->gb);
5446a41a00fe 10l (field select readed at the wrong place ...)
michaelni
parents: 666
diff changeset
3087 s->field_select[1][1]= get_bits1(&s->gb);
5446a41a00fe 10l (field select readed at the wrong place ...)
michaelni
parents: 666
diff changeset
3088 }
5446a41a00fe 10l (field select readed at the wrong place ...)
michaelni
parents: 666
diff changeset
3089 }
666
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3090 }
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3091
667
5446a41a00fe 10l (field select readed at the wrong place ...)
michaelni
parents: 666
diff changeset
3092 s->mv_dir = 0;
666
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3093 if(mb_type!=MB_TYPE_B_DIRECT && !field_mv){
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3094 s->mv_type= MV_TYPE_16X16;
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3095 if(mb_type!=MB_TYPE_B_BACKW){
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3096 s->mv_dir = MV_DIR_FORWARD;
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3097
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3098 mx = h263_decode_motion(s, s->last_mv[0][0][0], s->f_code);
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3099 my = h263_decode_motion(s, s->last_mv[0][0][1], s->f_code);
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3100 s->last_mv[0][1][0]= s->last_mv[0][0][0]= s->mv[0][0][0] = mx;
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3101 s->last_mv[0][1][1]= s->last_mv[0][0][1]= s->mv[0][0][1] = my;
667
5446a41a00fe 10l (field select readed at the wrong place ...)
michaelni
parents: 666
diff changeset
3102 }
666
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3103
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3104 if(mb_type!=MB_TYPE_B_FORW){
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3105 s->mv_dir |= MV_DIR_BACKWARD;
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3106
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3107 mx = h263_decode_motion(s, s->last_mv[1][0][0], s->b_code);
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3108 my = h263_decode_motion(s, s->last_mv[1][0][1], s->b_code);
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3109 s->last_mv[1][1][0]= s->last_mv[1][0][0]= s->mv[1][0][0] = mx;
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3110 s->last_mv[1][1][1]= s->last_mv[1][0][1]= s->mv[1][0][1] = my;
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3111 }
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3112 if(mb_type!=MB_TYPE_B_DIRECT)
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3113 PRINT_MB_TYPE(mb_type==MB_TYPE_B_FORW ? "F" : (mb_type==MB_TYPE_B_BACKW ? "B" : "T"));
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3114 }else if(mb_type!=MB_TYPE_B_DIRECT){
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3115 s->mv_type= MV_TYPE_FIELD;
667
5446a41a00fe 10l (field select readed at the wrong place ...)
michaelni
parents: 666
diff changeset
3116
666
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3117 if(mb_type!=MB_TYPE_B_BACKW){
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3118 s->mv_dir = MV_DIR_FORWARD;
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3119
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3120 for(i=0; i<2; i++){
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3121 mx = h263_decode_motion(s, s->last_mv[0][i][0] , s->f_code);
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3122 my = h263_decode_motion(s, s->last_mv[0][i][1]/2, s->f_code);
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3123 s->last_mv[0][i][0]= s->mv[0][i][0] = mx;
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3124 s->last_mv[0][i][1]= (s->mv[0][i][1] = my)*2;
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3125 }
667
5446a41a00fe 10l (field select readed at the wrong place ...)
michaelni
parents: 666
diff changeset
3126 }
666
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3127
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3128 if(mb_type!=MB_TYPE_B_FORW){
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3129 s->mv_dir |= MV_DIR_BACKWARD;
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3130
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3131 for(i=0; i<2; i++){
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3132 mx = h263_decode_motion(s, s->last_mv[1][i][0] , s->b_code);
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3133 my = h263_decode_motion(s, s->last_mv[1][i][1]/2, s->b_code);
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3134 s->last_mv[1][i][0]= s->mv[1][i][0] = mx;
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3135 s->last_mv[1][i][1]= (s->mv[1][i][1] = my)*2;
664
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
3136 }
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
3137 }
666
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3138 if(mb_type!=MB_TYPE_B_DIRECT)
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3139 PRINT_MB_TYPE(mb_type==MB_TYPE_B_FORW ? "f" : (mb_type==MB_TYPE_B_BACKW ? "b" : "t"));
664
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
3140 }
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
3141 }
666
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3142
664
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
3143 if(mb_type==4 || mb_type==MB_TYPE_B_DIRECT){
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
3144 int mb_index= s->mb_x + s->mb_y*s->mb_width;
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
3145 int i;
666
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3146
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3147 if(mb_type==4)
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3148 mx=my=0;
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3149 else{
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3150 mx = h263_decode_motion(s, 0, 1);
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3151 my = h263_decode_motion(s, 0, 1);
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3152 }
664
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
3153
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3154 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
266
252444e5259b optimization
michaelni
parents: 265
diff changeset
3155 xy= s->block_index[0];
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
3156 time_pp= s->pp_time;
664
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
3157 time_pb= s->pb_time;
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
3158
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3159 //FIXME avoid divides
664
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
3160 switch(s->co_located_type_table[mb_index]){
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
3161 case 0:
666
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3162 s->mv_type= MV_TYPE_16X16;
664
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
3163 s->mv[0][0][0] = s->motion_val[xy][0]*time_pb/time_pp + mx;
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
3164 s->mv[0][0][1] = s->motion_val[xy][1]*time_pb/time_pp + my;
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
3165 s->mv[1][0][0] = mx ? s->mv[0][0][0] - s->motion_val[xy][0]
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
3166 : s->motion_val[xy][0]*(time_pb - time_pp)/time_pp;
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
3167 s->mv[1][0][1] = my ? s->mv[0][0][1] - s->motion_val[xy][1]
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
3168 : s->motion_val[xy][1]*(time_pb - time_pp)/time_pp;
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
3169 PRINT_MB_TYPE(mb_type==4 ? "D" : "S");
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
3170 break;
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
3171 case CO_LOCATED_TYPE_4MV:
598
0c950f816d61 4mv + bframe decoding bugfix
michaelni
parents: 597
diff changeset
3172 s->mv_type = MV_TYPE_8X8;
664
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
3173 for(i=0; i<4; i++){
598
0c950f816d61 4mv + bframe decoding bugfix
michaelni
parents: 597
diff changeset
3174 xy= s->block_index[i];
0c950f816d61 4mv + bframe decoding bugfix
michaelni
parents: 597
diff changeset
3175 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
3176 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
3177 s->mv[1][i][0] = mx ? s->mv[0][i][0] - s->motion_val[xy][0]
656
e47fa3e3f2d5 statistics for forw & back p-MBs instead of just one counter for both
michaelni
parents: 654
diff changeset
3178 : s->motion_val[xy][0]*(time_pb - time_pp)/time_pp;
598
0c950f816d61 4mv + bframe decoding bugfix
michaelni
parents: 597
diff changeset
3179 s->mv[1][i][1] = my ? s->mv[0][i][1] - s->motion_val[xy][1]
656
e47fa3e3f2d5 statistics for forw & back p-MBs instead of just one counter for both
michaelni
parents: 654
diff changeset
3180 : s->motion_val[xy][1]*(time_pb - time_pp)/time_pp;
598
0c950f816d61 4mv + bframe decoding bugfix
michaelni
parents: 597
diff changeset
3181 }
0c950f816d61 4mv + bframe decoding bugfix
michaelni
parents: 597
diff changeset
3182 PRINT_MB_TYPE("4");
664
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
3183 break;
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
3184 case CO_LOCATED_TYPE_FIELDMV:
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
3185 s->mv_type = MV_TYPE_FIELD;
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
3186 for(i=0; i<2; i++){
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
3187 if(s->top_field_first){
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
3188 time_pp= s->pp_field_time - s->field_select_table[mb_index][i] + i;
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
3189 time_pb= s->pb_field_time - s->field_select_table[mb_index][i] + i;
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
3190 }else{
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
3191 time_pp= s->pp_field_time + s->field_select_table[mb_index][i] - i;
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
3192 time_pb= s->pb_field_time + s->field_select_table[mb_index][i] - i;
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
3193 }
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
3194 s->mv[0][i][0] = s->field_mv_table[mb_index][i][0]*time_pb/time_pp + mx;
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
3195 s->mv[0][i][1] = s->field_mv_table[mb_index][i][1]*time_pb/time_pp + my;
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
3196 s->mv[1][i][0] = mx ? s->mv[0][i][0] - s->field_mv_table[mb_index][i][0]
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
3197 : s->field_mv_table[mb_index][i][0]*(time_pb - time_pp)/time_pp;
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
3198 s->mv[1][i][1] = my ? s->mv[0][i][1] - s->field_mv_table[mb_index][i][1]
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
3199 : s->field_mv_table[mb_index][i][1]*(time_pb - time_pp)/time_pp;
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
3200 }
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
3201 PRINT_MB_TYPE("=");
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
3202 break;
598
0c950f816d61 4mv + bframe decoding bugfix
michaelni
parents: 597
diff changeset
3203 }
664
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
3204 }
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
3205
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
3206 if(mb_type<0 || mb_type>4){
364
6b6332e7008a segfault fix for b-frame encoding with height%16!=0
michaelni
parents: 360
diff changeset
3207 printf("illegal MB_type\n");
6b6332e7008a segfault fix for b-frame encoding with height%16!=0
michaelni
parents: 360
diff changeset
3208 return -1;
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3209 }
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3210 } else { /* I-Frame */
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
3211 cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 1);
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3212 if (cbpc < 0)
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3213 return -1;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3214 dquant = cbpc & 4;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3215 s->mb_intra = 1;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3216 intra:
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3217 s->ac_pred = 0;
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
3218 if (s->h263_pred || s->h263_aic) {
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
3219 s->ac_pred = get_bits1(&s->gb);
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
3220 if (s->ac_pred && s->h263_aic)
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
3221 s->h263_aic_dir = get_bits1(&s->gb);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3222 }
591
d3f374218030 fixing mpeg4 mpeg quantizers
michaelni
parents: 582
diff changeset
3223 PRINT_MB_TYPE(s->ac_pred ? "A" : "I");
d3f374218030 fixing mpeg4 mpeg quantizers
michaelni
parents: 582
diff changeset
3224
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
3225 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3226 if(cbpy<0) return -1;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3227 cbp = (cbpc & 3) | (cbpy << 2);
986e461dc072 Initial revision
glantau
parents:
diff changeset
3228 if (dquant) {
698
e050a053e259 h263_dc_scale() cleanup
michaelni
parents: 697
diff changeset
3229 change_qscale(s, quant_tab[get_bits(&s->gb, 2)]);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3230 }
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3231
619
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
3232 if(!s->progressive_sequence)
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
3233 s->interlaced_dct= get_bits1(&s->gb);
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
3234
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
3235 /* decode each block */
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
3236 if (s->h263_pred) {
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
3237 for (i = 0; i < 6; i++) {
718
16dab8296293 fixing custom quantizer matrix decoding
michaelni
parents: 706
diff changeset
3238 if (mpeg4_decode_block(s, block[i], i, cbp&32, 1) < 0)
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
3239 return -1;
718
16dab8296293 fixing custom quantizer matrix decoding
michaelni
parents: 706
diff changeset
3240 cbp+=cbp;
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
3241 }
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
3242 } else {
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
3243 for (i = 0; i < 6; i++) {
718
16dab8296293 fixing custom quantizer matrix decoding
michaelni
parents: 706
diff changeset
3244 if (h263_decode_block(s, block[i], i, cbp&32) < 0)
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
3245 return -1;
718
16dab8296293 fixing custom quantizer matrix decoding
michaelni
parents: 706
diff changeset
3246 cbp+=cbp;
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
3247 }
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
3248 }
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3249 goto end;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3250 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
3251
986e461dc072 Initial revision
glantau
parents:
diff changeset
3252 /* decode each block */
986e461dc072 Initial revision
glantau
parents:
diff changeset
3253 if (s->h263_pred) {
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
3254 for (i = 0; i < 6; i++) {
718
16dab8296293 fixing custom quantizer matrix decoding
michaelni
parents: 706
diff changeset
3255 if (mpeg4_decode_block(s, block[i], i, cbp&32, 0) < 0)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3256 return -1;
718
16dab8296293 fixing custom quantizer matrix decoding
michaelni
parents: 706
diff changeset
3257 cbp+=cbp;
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
3258 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3259 } else {
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
3260 for (i = 0; i < 6; i++) {
718
16dab8296293 fixing custom quantizer matrix decoding
michaelni
parents: 706
diff changeset
3261 if (h263_decode_block(s, block[i], i, cbp&32) < 0)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3262 return -1;
718
16dab8296293 fixing custom quantizer matrix decoding
michaelni
parents: 706
diff changeset
3263 cbp+=cbp;
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
3264 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3265 }
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3266 end:
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3267
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3268 /* per-MB end of slice check */
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3269 if(s->codec_id==CODEC_ID_MPEG4){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3270 if(mpeg4_is_resync(s)){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3271 if(s->pict_type==B_TYPE && s->mbskip_table[s->mb_y * s->mb_width + s->mb_x+1])
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3272 return SLICE_OK;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3273 return SLICE_END;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3274 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3275 }else{
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3276 if(get_bits_count(&s->gb) + 7 >= s->gb.size*8){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3277 int v= show_bits(&s->gb, 8) >> (((get_bits_count(&s->gb)-1)&7)+1);
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3278 if(v==0)
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3279 return SLICE_END;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3280 }else{
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3281 if(show_bits(&s->gb, 16)==0)
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3282 return SLICE_END;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3283 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3284 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3285
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3286 return SLICE_OK;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3287 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
3288
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3289 static int h263_decode_motion(MpegEncContext * s, int pred, int f_code)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3290 {
656
e47fa3e3f2d5 statistics for forw & back p-MBs instead of just one counter for both
michaelni
parents: 654
diff changeset
3291 int code, val, sign, shift, l;
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
3292 code = get_vlc2(&s->gb, mv_vlc.table, MV_VLC_BITS, 2);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3293 if (code < 0)
986e461dc072 Initial revision
glantau
parents:
diff changeset
3294 return 0xffff;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3295
986e461dc072 Initial revision
glantau
parents:
diff changeset
3296 if (code == 0)
986e461dc072 Initial revision
glantau
parents:
diff changeset
3297 return pred;
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
3298
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
3299 sign = get_bits1(&s->gb);
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3300 shift = f_code - 1;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3301 val = (code - 1) << shift;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3302 if (shift > 0)
986e461dc072 Initial revision
glantau
parents:
diff changeset
3303 val |= get_bits(&s->gb, shift);
986e461dc072 Initial revision
glantau
parents:
diff changeset
3304 val++;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3305 if (sign)
986e461dc072 Initial revision
glantau
parents:
diff changeset
3306 val = -val;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3307 val += pred;
475
6ccc48e4c41b run1 can be <0 bugfix (found by fabrice)
michaelni
parents: 469
diff changeset
3308
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3309 /* modulo decoding */
986e461dc072 Initial revision
glantau
parents:
diff changeset
3310 if (!s->h263_long_vectors) {
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
3311 l = 1 << (f_code + 4);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3312 if (val < -l) {
656
e47fa3e3f2d5 statistics for forw & back p-MBs instead of just one counter for both
michaelni
parents: 654
diff changeset
3313 val += l<<1;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3314 } else if (val >= l) {
656
e47fa3e3f2d5 statistics for forw & back p-MBs instead of just one counter for both
michaelni
parents: 654
diff changeset
3315 val -= l<<1;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3316 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
3317 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
3318 /* horrible h263 long vector mode */
986e461dc072 Initial revision
glantau
parents:
diff changeset
3319 if (pred < -31 && val < -63)
986e461dc072 Initial revision
glantau
parents:
diff changeset
3320 val += 64;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3321 if (pred > 32 && val > 63)
986e461dc072 Initial revision
glantau
parents:
diff changeset
3322 val -= 64;
154
f914f710b8d0 - Fixed a bug on H.263 MV prediction for MB on GOBs limits.
pulento
parents: 144
diff changeset
3323
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3324 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
3325 return val;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3326 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
3327
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3328 /* Decodes RVLC of H.263+ UMV */
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3329 static int h263p_decode_umotion(MpegEncContext * s, int pred)
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3330 {
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3331 int code = 0, sign;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3332
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3333 if (get_bits1(&s->gb)) /* Motion difference = 0 */
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3334 return pred;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3335
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3336 code = 2 + get_bits1(&s->gb);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3337
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3338 while (get_bits1(&s->gb))
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3339 {
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3340 code <<= 1;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3341 code += get_bits1(&s->gb);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3342 }
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3343 sign = code & 1;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3344 code >>= 1;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3345
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3346 code = (sign) ? (pred - code) : (pred + code);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3347 #ifdef DEBUG
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3348 fprintf(stderr,"H.263+ UMV Motion = %d\n", code);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3349 #endif
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3350 return code;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3351
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3352 }
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3353
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3354 static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
986e461dc072 Initial revision
glantau
parents:
diff changeset
3355 int n, int coded)
986e461dc072 Initial revision
glantau
parents:
diff changeset
3356 {
986e461dc072 Initial revision
glantau
parents:
diff changeset
3357 int code, level, i, j, last, run;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3358 RLTable *rl = &rl_inter;
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
3359 const UINT8 *scan_table;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3360
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
3361 scan_table = s->intra_scantable.permutated;
249
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
3362 if (s->h263_aic && s->mb_intra) {
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
3363 rl = &rl_intra_aic;
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
3364 i = 0;
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
3365 if (s->ac_pred) {
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
3366 if (s->h263_aic_dir)
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
3367 scan_table = s->intra_v_scantable.permutated; /* left */
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
3368 else
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
3369 scan_table = s->intra_h_scantable.permutated; /* top */
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
3370 }
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
3371 } else if (s->mb_intra) {
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
3372 /* DC coef */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3373 if (s->h263_rv10 && s->rv10_version == 3 && s->pict_type == I_TYPE) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
3374 int component, diff;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3375 component = (n <= 3 ? 0 : n - 4 + 1);
986e461dc072 Initial revision
glantau
parents:
diff changeset
3376 level = s->last_dc[component];
986e461dc072 Initial revision
glantau
parents:
diff changeset
3377 if (s->rv10_first_dc_coded[component]) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
3378 diff = rv_decode_dc(s, n);
986e461dc072 Initial revision
glantau
parents:
diff changeset
3379 if (diff == 0xffff)
986e461dc072 Initial revision
glantau
parents:
diff changeset
3380 return -1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3381 level += diff;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3382 level = level & 0xff; /* handle wrap round */
986e461dc072 Initial revision
glantau
parents:
diff changeset
3383 s->last_dc[component] = level;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3384 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
3385 s->rv10_first_dc_coded[component] = 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3386 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
3387 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
3388 level = get_bits(&s->gb, 8);
986e461dc072 Initial revision
glantau
parents:
diff changeset
3389 if (level == 255)
986e461dc072 Initial revision
glantau
parents:
diff changeset
3390 level = 128;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3391 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
3392 block[0] = level;
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
3393 i = 1;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3394 } else {
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
3395 i = 0;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3396 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
3397 if (!coded) {
249
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
3398 if (s->mb_intra && s->h263_aic)
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
3399 goto not_coded;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3400 s->block_last_index[n] = i - 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3401 return 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3402 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
3403
986e461dc072 Initial revision
glantau
parents:
diff changeset
3404 for(;;) {
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
3405 code = get_vlc2(&s->gb, rl->vlc.table, TEX_VLC_BITS, 2);
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3406 if (code < 0){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3407 fprintf(stderr, "illegal ac vlc code at %dx%d\n", s->mb_x, s->mb_y);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3408 return -1;
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3409 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3410 if (code == rl->n) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
3411 /* escape */
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
3412 last = get_bits1(&s->gb);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3413 run = get_bits(&s->gb, 6);
986e461dc072 Initial revision
glantau
parents:
diff changeset
3414 level = (INT8)get_bits(&s->gb, 8);
986e461dc072 Initial revision
glantau
parents:
diff changeset
3415 if (s->h263_rv10 && level == -128) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
3416 /* XXX: should patch encoder too */
986e461dc072 Initial revision
glantau
parents:
diff changeset
3417 level = get_bits(&s->gb, 12);
669
b4bddbde44f3 aspect (ext. par too) support for h263 and mpeg4 (inc. build becouse of new vars)
al3x
parents: 667
diff changeset
3418 level= (level + ((-1)<<11)) ^ ((-1)<<11); //sign extension
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3419 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
3420 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
3421 run = rl->table_run[code];
986e461dc072 Initial revision
glantau
parents:
diff changeset
3422 level = rl->table_level[code];
986e461dc072 Initial revision
glantau
parents:
diff changeset
3423 last = code >= rl->last;
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
3424 if (get_bits1(&s->gb))
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3425 level = -level;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3426 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
3427 i += run;
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3428 if (i >= 64){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3429 fprintf(stderr, "run overflow at %dx%d\n", s->mb_x, s->mb_y);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3430 return -1;
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3431 }
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
3432 j = scan_table[i];
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3433 block[j] = level;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3434 if (last)
986e461dc072 Initial revision
glantau
parents:
diff changeset
3435 break;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3436 i++;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3437 }
249
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
3438 not_coded:
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
3439 if (s->mb_intra && s->h263_aic) {
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
3440 h263_pred_acdc(s, block, n);
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
3441 i = 63;
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
3442 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3443 s->block_last_index[n] = i;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3444 return 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3445 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
3446
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3447 static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3448 {
986e461dc072 Initial revision
glantau
parents:
diff changeset
3449 int level, pred, code;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3450 UINT16 *dc_val;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3451
986e461dc072 Initial revision
glantau
parents:
diff changeset
3452 if (n < 4)
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
3453 code = get_vlc2(&s->gb, dc_lum.table, DC_VLC_BITS, 1);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3454 else
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
3455 code = get_vlc2(&s->gb, dc_chrom.table, DC_VLC_BITS, 1);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3456 if (code < 0 || code > 9 /* && s->nbit<9 */){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3457 fprintf(stderr, "illegal dc vlc\n");
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3458 return -1;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3459 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3460 if (code == 0) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
3461 level = 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3462 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
3463 level = get_bits(&s->gb, code);
986e461dc072 Initial revision
glantau
parents:
diff changeset
3464 if ((level >> (code - 1)) == 0) /* if MSB not set it is negative*/
986e461dc072 Initial revision
glantau
parents:
diff changeset
3465 level = - (level ^ ((1 << code) - 1));
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3466 if (code > 8){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3467 if(get_bits1(&s->gb)==0){ /* marker */
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3468 if(s->error_resilience>=2){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3469 fprintf(stderr, "dc marker bit missing\n");
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3470 return -1;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3471 }
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3472 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3473 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3474 }
498
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
3475 pred = ff_mpeg4_pred_dc(s, n, &dc_val, dir_ptr);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3476 level += pred;
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3477 if (level < 0){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3478 if(s->error_resilience>=3){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3479 fprintf(stderr, "dc<0 at %dx%d\n", s->mb_x, s->mb_y);
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3480 return -1;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3481 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3482 level = 0;
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3483 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3484 if (n < 4) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
3485 *dc_val = level * s->y_dc_scale;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3486 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
3487 *dc_val = level * s->c_dc_scale;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3488 }
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3489 if(s->error_resilience>=3){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3490 if(*dc_val > 2048 + s->y_dc_scale + s->c_dc_scale){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3491 fprintf(stderr, "dc overflow at %dx%d\n", s->mb_x, s->mb_y);
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3492 return -1;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3493 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3494 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3495 return level;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3496 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
3497
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3498 /**
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3499 * decodes a block.
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3500 * @return <0 if an error occured
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3501 */
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3502 static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
3503 int n, int coded, int intra)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3504 {
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3505 int level, i, last, run;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3506 int dc_pred_dir;
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
3507 RLTable * rl;
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
3508 RL_VLC_ELEM * rl_vlc;
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
3509 const UINT8 * scan_table;
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3510 int qmul, qadd;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3511
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
3512 if(intra) {
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3513 /* DC coef */
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3514 if(s->partitioned_frame){
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3515 level = s->dc_val[0][ s->block_index[n] ];
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3516 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
3517 else level= (level + (s->c_dc_scale>>1))/s->c_dc_scale;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3518 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
3519 }else{
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3520 level = mpeg4_decode_dc(s, n, &dc_pred_dir);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3521 if (level < 0)
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3522 return -1;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3523 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3524 block[0] = level;
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3525 i = 0;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3526 if (!coded)
986e461dc072 Initial revision
glantau
parents:
diff changeset
3527 goto not_coded;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3528 rl = &rl_intra;
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3529 rl_vlc = rl_intra.rl_vlc[0];
718
16dab8296293 fixing custom quantizer matrix decoding
michaelni
parents: 706
diff changeset
3530 if (s->ac_pred) {
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3531 if (dc_pred_dir == 0)
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
3532 scan_table = s->intra_v_scantable.permutated; /* left */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3533 else
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
3534 scan_table = s->intra_h_scantable.permutated; /* top */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3535 } else {
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
3536 scan_table = s->intra_scantable.permutated;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3537 }
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3538 qmul=1;
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3539 qadd=0;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3540 } else {
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3541 i = -1;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3542 if (!coded) {
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3543 s->block_last_index[n] = i;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3544 return 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3545 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
3546 rl = &rl_inter;
661
a0901e38c564 fixing interlaced mpeg4 decoding
michaelni
parents: 660
diff changeset
3547
718
16dab8296293 fixing custom quantizer matrix decoding
michaelni
parents: 706
diff changeset
3548 scan_table = s->intra_scantable.permutated;
661
a0901e38c564 fixing interlaced mpeg4 decoding
michaelni
parents: 660
diff changeset
3549
591
d3f374218030 fixing mpeg4 mpeg quantizers
michaelni
parents: 582
diff changeset
3550 if(s->mpeg_quant){
d3f374218030 fixing mpeg4 mpeg quantizers
michaelni
parents: 582
diff changeset
3551 qmul=1;
d3f374218030 fixing mpeg4 mpeg quantizers
michaelni
parents: 582
diff changeset
3552 qadd=0;
d3f374218030 fixing mpeg4 mpeg quantizers
michaelni
parents: 582
diff changeset
3553 rl_vlc = rl_inter.rl_vlc[0];
d3f374218030 fixing mpeg4 mpeg quantizers
michaelni
parents: 582
diff changeset
3554 }else{
d3f374218030 fixing mpeg4 mpeg quantizers
michaelni
parents: 582
diff changeset
3555 qmul = s->qscale << 1;
d3f374218030 fixing mpeg4 mpeg quantizers
michaelni
parents: 582
diff changeset
3556 qadd = (s->qscale - 1) | 1;
d3f374218030 fixing mpeg4 mpeg quantizers
michaelni
parents: 582
diff changeset
3557 rl_vlc = rl_inter.rl_vlc[s->qscale];
d3f374218030 fixing mpeg4 mpeg quantizers
michaelni
parents: 582
diff changeset
3558 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3559 }
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3560 {
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3561 OPEN_READER(re, &s->gb);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3562 for(;;) {
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3563 UPDATE_CACHE(re, &s->gb);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3564 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3565 if (level==0) {
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3566 int cache;
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3567 cache= GET_CACHE(re, &s->gb);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3568 /* escape */
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3569 if (cache&0x80000000) {
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3570 if (cache&0x40000000) {
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3571 /* third escape */
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3572 SKIP_CACHE(re, &s->gb, 2);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3573 last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3574 run= SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3575 SKIP_COUNTER(re, &s->gb, 2+1+6);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3576 UPDATE_CACHE(re, &s->gb);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3577
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3578 if(SHOW_UBITS(re, &s->gb, 1)==0){
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3579 fprintf(stderr, "1. marker bit missing in 3. esc\n");
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3580 return -1;
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3581 }; SKIP_CACHE(re, &s->gb, 1);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3582
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3583 level= SHOW_SBITS(re, &s->gb, 12); SKIP_CACHE(re, &s->gb, 12);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3584
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3585 if(SHOW_UBITS(re, &s->gb, 1)==0){
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3586 fprintf(stderr, "2. marker bit missing in 3. esc\n");
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3587 return -1;
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3588 }; LAST_SKIP_CACHE(re, &s->gb, 1);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3589
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3590 SKIP_COUNTER(re, &s->gb, 1+12+1);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3591
597
d5d0c11ea4cf fixing level overflow check for qp=1
michaelni
parents: 591
diff changeset
3592 if(level*s->qscale>1024 || level*s->qscale<-1024){
d5d0c11ea4cf fixing level overflow check for qp=1
michaelni
parents: 591
diff changeset
3593 fprintf(stderr, "|level| overflow in 3. esc, qp=%d\n", s->qscale);
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3594 return -1;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3595 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3596 #if 1
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3597 {
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3598 const int abs_level= ABS(level);
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3599 if(abs_level<=MAX_LEVEL && run<=MAX_RUN && ((s->workaround_bugs&FF_BUG_AC_VLC)==0)){
498
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
3600 const int run1= run - rl->max_run[last][abs_level] - 1;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3601 if(abs_level <= rl->max_level[last][run]){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3602 fprintf(stderr, "illegal 3. esc, vlc encoding possible\n");
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3603 return -1;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3604 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3605 if(abs_level <= rl->max_level[last][run]*2){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3606 fprintf(stderr, "illegal 3. esc, esc 1 encoding possible\n");
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3607 return -1;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3608 }
475
6ccc48e4c41b run1 can be <0 bugfix (found by fabrice)
michaelni
parents: 469
diff changeset
3609 if(run1 >= 0 && abs_level <= rl->max_level[last][run1]){
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3610 fprintf(stderr, "illegal 3. esc, esc 2 encoding possible\n");
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3611 return -1;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3612 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3613 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3614 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3615 #endif
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3616 if (level>0) level= level * qmul + qadd;
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3617 else level= level * qmul - qadd;
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3618
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3619 i+= run + 1;
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3620 if(last) i+=192;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3621 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
3622 /* second escape */
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3623 #if MIN_CACHE_BITS < 20
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3624 LAST_SKIP_BITS(re, &s->gb, 2);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3625 UPDATE_CACHE(re, &s->gb);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3626 #else
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3627 SKIP_BITS(re, &s->gb, 2);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3628 #endif
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3629 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3630 i+= run + rl->max_run[run>>7][level/qmul] +1; //FIXME opt indexing
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3631 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3632 LAST_SKIP_BITS(re, &s->gb, 1);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3633 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
3634 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
3635 /* first escape */
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3636 #if MIN_CACHE_BITS < 19
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3637 LAST_SKIP_BITS(re, &s->gb, 1);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3638 UPDATE_CACHE(re, &s->gb);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3639 #else
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3640 SKIP_BITS(re, &s->gb, 1);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3641 #endif
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3642 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3643 i+= run;
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3644 level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//FIXME opt indexing
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3645 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3646 LAST_SKIP_BITS(re, &s->gb, 1);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3647 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
3648 } else {
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3649 i+= run;
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3650 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3651 LAST_SKIP_BITS(re, &s->gb, 1);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3652 }
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3653 if (i > 62){
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3654 i-= 192;
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3655 if(i&(~63)){
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3656 fprintf(stderr, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3657 return -1;
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3658 }
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3659
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3660 block[scan_table[i]] = level;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3661 break;
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3662 }
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3663
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3664 block[scan_table[i]] = level;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3665 }
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3666 CLOSE_READER(re, &s->gb);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3667 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3668 not_coded:
986e461dc072 Initial revision
glantau
parents:
diff changeset
3669 if (s->mb_intra) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
3670 mpeg4_pred_ac(s, block, n, dc_pred_dir);
986e461dc072 Initial revision
glantau
parents:
diff changeset
3671 if (s->ac_pred) {
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3672 i = 63; /* XXX: not optimal */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3673 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
3674 }
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3675 s->block_last_index[n] = i;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3676 return 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3677 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
3678
986e461dc072 Initial revision
glantau
parents:
diff changeset
3679 /* most is hardcoded. should extend to handle all h263 streams */
986e461dc072 Initial revision
glantau
parents:
diff changeset
3680 int h263_decode_picture_header(MpegEncContext *s)
986e461dc072 Initial revision
glantau
parents:
diff changeset
3681 {
986e461dc072 Initial revision
glantau
parents:
diff changeset
3682 int format, width, height;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3683
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3684 /* picture start code */
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3685 if (get_bits(&s->gb, 22) != 0x20) {
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3686 fprintf(stderr, "Bad picture start code\n");
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3687 return -1;
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3688 }
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3689 /* temporal reference */
231
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
3690 s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3691
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3692 /* PTYPE starts here */
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3693 if (get_bits1(&s->gb) != 1) {
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3694 /* marker */
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3695 fprintf(stderr, "Bad marker\n");
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3696 return -1;
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3697 }
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3698 if (get_bits1(&s->gb) != 0) {
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3699 fprintf(stderr, "Bad H263 id\n");
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3700 return -1; /* h263 id */
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3701 }
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
3702 skip_bits1(&s->gb); /* split screen off */
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
3703 skip_bits1(&s->gb); /* camera off */
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
3704 skip_bits1(&s->gb); /* freeze picture release off */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3705
155
3c3449bce692 - Bug fix on MV prediction for MPEG4 caused by new H.263 GOB code.
pulento
parents: 154
diff changeset
3706 /* Reset GOB number */
154
f914f710b8d0 - Fixed a bug on H.263 MV prediction for MB on GOBs limits.
pulento
parents: 144
diff changeset
3707 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
3708
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3709 format = get_bits(&s->gb, 3);
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3710 /*
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3711 0 forbidden
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3712 1 sub-QCIF
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3713 10 QCIF
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3714 7 extended PTYPE (PLUSPTYPE)
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3715 */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3716
161
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3717 if (format != 7 && format != 6) {
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3718 s->h263_plus = 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3719 /* H.263v1 */
986e461dc072 Initial revision
glantau
parents:
diff changeset
3720 width = h263_format[format][0];
986e461dc072 Initial revision
glantau
parents:
diff changeset
3721 height = h263_format[format][1];
986e461dc072 Initial revision
glantau
parents:
diff changeset
3722 if (!width)
986e461dc072 Initial revision
glantau
parents:
diff changeset
3723 return -1;
161
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3724
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3725 s->width = width;
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3726 s->height = height;
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
3727 s->pict_type = I_TYPE + get_bits1(&s->gb);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3728
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
3729 s->unrestricted_mv = get_bits1(&s->gb);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3730 s->h263_long_vectors = s->unrestricted_mv;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3731
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3732 if (get_bits1(&s->gb) != 0) {
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3733 fprintf(stderr, "H263 SAC not supported\n");
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3734 return -1; /* SAC: off */
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3735 }
161
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3736 if (get_bits1(&s->gb) != 0) {
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3737 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
3738 }
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3739
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3740 if (get_bits1(&s->gb) != 0) {
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3741 fprintf(stderr, "H263 PB frame not supported\n");
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3742 return -1; /* not PB frame */
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3743 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3744 s->qscale = get_bits(&s->gb, 5);
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
3745 skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3746 } else {
161
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3747 int ufep;
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3748
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3749 /* H.263v2 */
161
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3750 s->h263_plus = 1;
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3751 ufep = get_bits(&s->gb, 3); /* Update Full Extended PTYPE */
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3752
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3753 /* 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
3754 if (ufep == 1) {
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3755 /* OPPTYPE */
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3756 format = get_bits(&s->gb, 3);
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3757 dprintf("ufep=1, format: %d\n", format);
161
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3758 skip_bits(&s->gb,1); /* Custom PCF */
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3759 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
3760 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
3761 if (get_bits1(&s->gb) != 0) {
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3762 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
3763 }
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
3764 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
3765 s->h263_aic = 1;
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
3766 }
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3767
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
3768 skip_bits(&s->gb, 7);
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3769 /* these are the 7 bits: (in order of appearence */
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3770 /* Deblocking Filter */
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3771 /* Slice Structured */
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3772 /* Reference Picture Selection */
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3773 /* Independent Segment Decoding */
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3774 /* Alternative Inter VLC */
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3775 /* Modified Quantization */
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3776 /* Prevent start code emulation */
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3777
161
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3778 skip_bits(&s->gb, 3); /* Reserved */
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3779 } else if (ufep != 0) {
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3780 fprintf(stderr, "Bad UFEP type (%d)\n", ufep);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3781 return -1;
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3782 }
161
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3783
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3784 /* MPPTYPE */
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3785 s->pict_type = get_bits(&s->gb, 3) + I_TYPE;
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3786 dprintf("pict_type: %d\n", s->pict_type);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3787 if (s->pict_type != I_TYPE &&
986e461dc072 Initial revision
glantau
parents:
diff changeset
3788 s->pict_type != P_TYPE)
986e461dc072 Initial revision
glantau
parents:
diff changeset
3789 return -1;
250
3449316664b5 - Bug fix on RTYPE (rounding type) not being honoured by H.263+ decoder.
pulento
parents: 249
diff changeset
3790 skip_bits(&s->gb, 2);
3449316664b5 - Bug fix on RTYPE (rounding type) not being honoured by H.263+ decoder.
pulento
parents: 249
diff changeset
3791 s->no_rounding = get_bits1(&s->gb);
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3792 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
3793 skip_bits(&s->gb, 4);
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3794
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3795 /* Get the picture dimensions */
161
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3796 if (ufep) {
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3797 if (format == 6) {
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3798 /* Custom Picture Format (CPFMT) */
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3799 s->aspect_ratio_info = get_bits(&s->gb, 4);
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3800 dprintf("aspect: %d\n", s->aspect_ratio_info);
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3801 /* aspect ratios:
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3802 0 - forbidden
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3803 1 - 1:1
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3804 2 - 12:11 (CIF 4:3)
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3805 3 - 10:11 (525-type 4:3)
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3806 4 - 16:11 (CIF 16:9)
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3807 5 - 40:33 (525-type 16:9)
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3808 6-14 - reserved
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3809 */
161
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3810 width = (get_bits(&s->gb, 9) + 1) * 4;
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3811 skip_bits1(&s->gb);
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3812 height = get_bits(&s->gb, 9) * 4;
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3813 dprintf("\nH.263+ Custom picture: %dx%d\n",width,height);
669
b4bddbde44f3 aspect (ext. par too) support for h263 and mpeg4 (inc. build becouse of new vars)
al3x
parents: 667
diff changeset
3814 if (s->aspect_ratio_info == FF_ASPECT_EXTENDED) {
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3815 /* aspected dimensions */
669
b4bddbde44f3 aspect (ext. par too) support for h263 and mpeg4 (inc. build becouse of new vars)
al3x
parents: 667
diff changeset
3816 s->aspected_width = get_bits(&s->gb, 8);
b4bddbde44f3 aspect (ext. par too) support for h263 and mpeg4 (inc. build becouse of new vars)
al3x
parents: 667
diff changeset
3817 s->aspected_height = get_bits(&s->gb, 8);
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3818 }
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3819 } else {
161
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3820 width = h263_format[format][0];
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3821 height = h263_format[format][1];
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3822 }
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3823 if ((width == 0) || (height == 0))
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3824 return -1;
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3825 s->width = width;
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3826 s->height = height;
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3827 if (s->umvplus_dec) {
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3828 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
3829 }
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3830 }
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3831
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3832 s->qscale = get_bits(&s->gb, 5);
986e461dc072 Initial revision
glantau
parents:
diff changeset
3833 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
3834 /* PEI */
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
3835 while (get_bits1(&s->gb) != 0) {
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
3836 skip_bits(&s->gb, 8);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3837 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
3838 s->f_code = 1;
498
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
3839
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
3840 if(s->h263_aic){
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
3841 s->y_dc_scale_table=
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
3842 s->c_dc_scale_table= h263_aic_dc_scale_table;
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
3843 }else{
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
3844 s->y_dc_scale_table=
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
3845 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
3846 }
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
3847
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3848 return 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3849 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
3850
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3851 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
3852 {
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3853 int i;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3854 int a= 2<<s->sprite_warping_accuracy;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3855 int rho= 3-s->sprite_warping_accuracy;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3856 int r=16/a;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3857 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
3858 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
3859 int sprite_ref[4][2];
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3860 int virtual_ref[2][2];
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3861 int w2, h2, w3, h3;
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3862 int alpha=0, beta=0;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3863 int w= s->width;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3864 int h= s->height;
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3865 int min_ab;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3866
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3867 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
3868 int length;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3869 int x=0, y=0;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3870
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3871 length= get_vlc(&s->gb, &sprite_trajectory);
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3872 if(length){
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3873 x= get_bits(&s->gb, length);
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3874
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3875 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
3876 x = - (x ^ ((1 << length) - 1));
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3877 }
255
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
3878 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
3879
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3880 length= get_vlc(&s->gb, &sprite_trajectory);
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3881 if(length){
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3882 y=get_bits(&s->gb, length);
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3883
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3884 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
3885 y = - (y ^ ((1 << length) - 1));
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3886 }
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3887 skip_bits1(&s->gb); /* marker bit */
255
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
3888 //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
3889 d[i][0]= x;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3890 d[i][1]= y;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3891 }
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3892
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3893 while((1<<alpha)<w) alpha++;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3894 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
3895 w2= 1<<alpha;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3896 h2= 1<<beta;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3897
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3898 // Note, the 4th point isnt used for GMC
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3899 if(s->divx_version==500 && s->divx_build==413){
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3900 sprite_ref[0][0]= a*vop_ref[0][0] + d[0][0];
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3901 sprite_ref[0][1]= a*vop_ref[0][1] + d[0][1];
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3902 sprite_ref[1][0]= a*vop_ref[1][0] + d[0][0] + d[1][0];
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3903 sprite_ref[1][1]= a*vop_ref[1][1] + d[0][1] + d[1][1];
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3904 sprite_ref[2][0]= a*vop_ref[2][0] + d[0][0] + d[2][0];
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3905 sprite_ref[2][1]= a*vop_ref[2][1] + d[0][1] + d[2][1];
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3906 } else {
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3907 sprite_ref[0][0]= (a>>1)*(2*vop_ref[0][0] + d[0][0]);
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3908 sprite_ref[0][1]= (a>>1)*(2*vop_ref[0][1] + d[0][1]);
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3909 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
3910 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
3911 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
3912 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
3913 }
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3914 /* 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
3915 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
3916
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3917 // 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
3918 // 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
3919 // 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
3920 // 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
3921 virtual_ref[0][0]= 16*(vop_ref[0][0] + w2)
359
df0736462b9f move ABS() to common.h
michaelni
parents: 358
diff changeset
3922 + 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
3923 virtual_ref[0][1]= 16*vop_ref[0][1]
359
df0736462b9f move ABS() to common.h
michaelni
parents: 358
diff changeset
3924 + 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
3925 virtual_ref[1][0]= 16*vop_ref[0][0]
359
df0736462b9f move ABS() to common.h
michaelni
parents: 358
diff changeset
3926 + 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
3927 virtual_ref[1][1]= 16*(vop_ref[0][1] + h2)
359
df0736462b9f move ABS() to common.h
michaelni
parents: 358
diff changeset
3928 + 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);
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3929
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3930 switch(s->num_sprite_warping_points)
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3931 {
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3932 case 0:
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3933 s->sprite_offset[0][0]= 0;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3934 s->sprite_offset[0][1]= 0;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3935 s->sprite_offset[1][0]= 0;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3936 s->sprite_offset[1][1]= 0;
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3937 s->sprite_delta[0][0]= a;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3938 s->sprite_delta[0][1]= 0;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3939 s->sprite_delta[1][0]= 0;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3940 s->sprite_delta[1][1]= a;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3941 s->sprite_shift[0]= 0;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3942 s->sprite_shift[1]= 0;
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3943 break;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3944 case 1: //GMC only
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3945 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
3946 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
3947 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
3948 s->sprite_offset[1][1]= ((sprite_ref[0][1]>>1)|(sprite_ref[0][1]&1)) - a*(vop_ref[0][1]/2);
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3949 s->sprite_delta[0][0]= a;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3950 s->sprite_delta[0][1]= 0;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3951 s->sprite_delta[1][0]= 0;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3952 s->sprite_delta[1][1]= a;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3953 s->sprite_shift[0]= 0;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3954 s->sprite_shift[1]= 0;
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3955 break;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3956 case 2:
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3957 s->sprite_offset[0][0]= (sprite_ref[0][0]<<(alpha+rho))
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3958 + (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][0])
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3959 + ( r*sprite_ref[0][1] - virtual_ref[0][1])*(-vop_ref[0][1])
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3960 + (1<<(alpha+rho-1));
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3961 s->sprite_offset[0][1]= (sprite_ref[0][1]<<(alpha+rho))
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3962 + (-r*sprite_ref[0][1] + virtual_ref[0][1])*(-vop_ref[0][0])
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3963 + (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][1])
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3964 + (1<<(alpha+rho-1));
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3965 s->sprite_offset[1][0]= ( (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][0] + 1)
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3966 +( r*sprite_ref[0][1] - virtual_ref[0][1])*(-2*vop_ref[0][1] + 1)
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3967 +2*w2*r*sprite_ref[0][0]
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3968 - 16*w2
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3969 + (1<<(alpha+rho+1)));
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3970 s->sprite_offset[1][1]= ( (-r*sprite_ref[0][1] + virtual_ref[0][1])*(-2*vop_ref[0][0] + 1)
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3971 +(-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][1] + 1)
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3972 +2*w2*r*sprite_ref[0][1]
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3973 - 16*w2
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3974 + (1<<(alpha+rho+1)));
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3975 s->sprite_delta[0][0]= (-r*sprite_ref[0][0] + virtual_ref[0][0]);
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3976 s->sprite_delta[0][1]= (+r*sprite_ref[0][1] - virtual_ref[0][1]);
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3977 s->sprite_delta[1][0]= (-r*sprite_ref[0][1] + virtual_ref[0][1]);
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3978 s->sprite_delta[1][1]= (-r*sprite_ref[0][0] + virtual_ref[0][0]);
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3979
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3980 s->sprite_shift[0]= alpha+rho;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3981 s->sprite_shift[1]= alpha+rho+2;
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3982 break;
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3983 case 3:
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3984 min_ab= MIN(alpha, beta);
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3985 w3= w2>>min_ab;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3986 h3= h2>>min_ab;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3987 s->sprite_offset[0][0]= (sprite_ref[0][0]<<(alpha+beta+rho-min_ab))
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3988 + (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3*(-vop_ref[0][0])
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3989 + (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3*(-vop_ref[0][1])
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3990 + (1<<(alpha+beta+rho-min_ab-1));
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3991 s->sprite_offset[0][1]= (sprite_ref[0][1]<<(alpha+beta+rho-min_ab))
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3992 + (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3*(-vop_ref[0][0])
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3993 + (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3*(-vop_ref[0][1])
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3994 + (1<<(alpha+beta+rho-min_ab-1));
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3995 s->sprite_offset[1][0]= (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3*(-2*vop_ref[0][0] + 1)
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3996 + (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3*(-2*vop_ref[0][1] + 1)
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3997 + 2*w2*h3*r*sprite_ref[0][0]
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3998 - 16*w2*h3
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3999 + (1<<(alpha+beta+rho-min_ab+1));
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4000 s->sprite_offset[1][1]= (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3*(-2*vop_ref[0][0] + 1)
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4001 + (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3*(-2*vop_ref[0][1] + 1)
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4002 + 2*w2*h3*r*sprite_ref[0][1]
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4003 - 16*w2*h3
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4004 + (1<<(alpha+beta+rho-min_ab+1));
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4005 s->sprite_delta[0][0]= (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4006 s->sprite_delta[0][1]= (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4007 s->sprite_delta[1][0]= (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4008 s->sprite_delta[1][1]= (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4009
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4010 s->sprite_shift[0]= alpha + beta + rho - min_ab;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4011 s->sprite_shift[1]= alpha + beta + rho - min_ab + 2;
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
4012 break;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
4013 }
255
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
4014 /* try to simplify the situation */
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4015 if( s->sprite_delta[0][0] == a<<s->sprite_shift[0]
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4016 && s->sprite_delta[0][1] == 0
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4017 && s->sprite_delta[1][0] == 0
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4018 && s->sprite_delta[1][1] == a<<s->sprite_shift[0])
255
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
4019 {
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4020 s->sprite_offset[0][0]>>=s->sprite_shift[0];
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4021 s->sprite_offset[0][1]>>=s->sprite_shift[0];
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4022 s->sprite_offset[1][0]>>=s->sprite_shift[1];
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4023 s->sprite_offset[1][1]>>=s->sprite_shift[1];
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4024 s->sprite_delta[0][0]= a;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4025 s->sprite_delta[0][1]= 0;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4026 s->sprite_delta[1][0]= 0;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4027 s->sprite_delta[1][1]= a;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4028 s->sprite_shift[0]= 0;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4029 s->sprite_shift[1]= 0;
255
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
4030 s->real_sprite_warping_points=1;
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
4031 }
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4032 else{
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4033 int shift_y= 16 - s->sprite_shift[0];
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4034 int shift_c= 16 - s->sprite_shift[1];
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4035 //printf("shifts %d %d\n", shift_y, shift_c);
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4036 for(i=0; i<2; i++){
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4037 s->sprite_offset[0][i]<<= shift_y;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4038 s->sprite_offset[1][i]<<= shift_c;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4039 s->sprite_delta[0][i]<<= shift_y;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4040 s->sprite_delta[1][i]<<= shift_y;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4041 s->sprite_shift[i]= 16;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4042 }
255
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
4043 s->real_sprite_warping_points= s->num_sprite_warping_points;
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4044 }
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4045 #if 0
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4046 printf("vop:%d:%d %d:%d %d:%d, sprite:%d:%d %d:%d %d:%d, virtual: %d:%d %d:%d\n",
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4047 vop_ref[0][0], vop_ref[0][1],
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4048 vop_ref[1][0], vop_ref[1][1],
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4049 vop_ref[2][0], vop_ref[2][1],
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4050 sprite_ref[0][0], sprite_ref[0][1],
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4051 sprite_ref[1][0], sprite_ref[1][1],
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4052 sprite_ref[2][0], sprite_ref[2][1],
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4053 virtual_ref[0][0], virtual_ref[0][1],
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4054 virtual_ref[1][0], virtual_ref[1][1]
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4055 );
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4056
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4057 printf("offset: %d:%d , delta: %d %d %d %d, shift %d\n",
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4058 s->sprite_offset[0][0], s->sprite_offset[0][1],
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4059 s->sprite_delta[0][0], s->sprite_delta[0][1],
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4060 s->sprite_delta[1][0], s->sprite_delta[1][1],
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4061 s->sprite_shift[0]
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4062 );
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4063 #endif
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
4064 }
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
4065
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4066 static int decode_vol_header(MpegEncContext *s, GetBitContext *gb){
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4067 int width, height, vo_ver_id;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4068
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4069 /* vol header */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4070 skip_bits(gb, 1); /* random access */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4071 s->vo_type= get_bits(gb, 8);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4072 if (get_bits1(gb) != 0) { /* is_ol_id */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4073 vo_ver_id = get_bits(gb, 4); /* vo_ver_id */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4074 skip_bits(gb, 3); /* vo_priority */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4075 } else {
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4076 vo_ver_id = 1;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4077 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4078 //printf("vo type:%d\n",s->vo_type);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4079 s->aspect_ratio_info= get_bits(gb, 4);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4080 if(s->aspect_ratio_info == FF_ASPECT_EXTENDED){
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4081 s->aspected_width = get_bits(gb, 8); // par_width
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4082 s->aspected_height = get_bits(gb, 8); // par_height
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4083 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4084
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4085 if ((s->vol_control_parameters=get_bits1(gb))) { /* vol control parameter */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4086 int chroma_format= get_bits(gb, 2);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4087 if(chroma_format!=1){
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4088 printf("illegal chroma format\n");
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4089 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4090 s->low_delay= get_bits1(gb);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4091 if(get_bits1(gb)){ /* vbv parameters */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4092 get_bits(gb, 15); /* first_half_bitrate */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4093 skip_bits1(gb); /* marker */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4094 get_bits(gb, 15); /* latter_half_bitrate */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4095 skip_bits1(gb); /* marker */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4096 get_bits(gb, 15); /* first_half_vbv_buffer_size */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4097 skip_bits1(gb); /* marker */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4098 get_bits(gb, 3); /* latter_half_vbv_buffer_size */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4099 get_bits(gb, 11); /* first_half_vbv_occupancy */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4100 skip_bits1(gb); /* marker */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4101 get_bits(gb, 15); /* latter_half_vbv_occupancy */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4102 skip_bits1(gb); /* marker */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4103 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4104 }else{
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4105 // set low delay flag only once so the smart? low delay detection wont be overriden
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4106 if(s->picture_number==0)
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4107 s->low_delay=0;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4108 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4109
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4110 s->shape = get_bits(gb, 2); /* vol shape */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4111 if(s->shape != RECT_SHAPE) printf("only rectangular vol supported\n");
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4112 if(s->shape == GRAY_SHAPE && vo_ver_id != 1){
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4113 printf("Gray shape not supported\n");
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4114 skip_bits(gb, 4); //video_object_layer_shape_extension
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4115 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4116
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4117 skip_bits1(gb); /* marker */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4118
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4119 s->time_increment_resolution = get_bits(gb, 16);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4120
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4121 s->time_increment_bits = av_log2(s->time_increment_resolution - 1) + 1;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4122 if (s->time_increment_bits < 1)
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4123 s->time_increment_bits = 1;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4124 skip_bits1(gb); /* marker */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4125
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4126 if (get_bits1(gb) != 0) { /* fixed_vop_rate */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4127 skip_bits(gb, s->time_increment_bits);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4128 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4129
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4130 if (s->shape != BIN_ONLY_SHAPE) {
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4131 if (s->shape == RECT_SHAPE) {
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4132 skip_bits1(gb); /* marker */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4133 width = get_bits(gb, 13);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4134 skip_bits1(gb); /* marker */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4135 height = get_bits(gb, 13);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4136 skip_bits1(gb); /* marker */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4137 if(width && height){ /* they should be non zero but who knows ... */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4138 s->width = width;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4139 s->height = height;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4140 // printf("width/height: %d %d\n", width, height);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4141 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4142 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4143
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4144 s->progressive_sequence= get_bits1(gb)^1;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4145 if(!get_bits1(gb)) printf("OBMC not supported (very likely buggy encoder)\n"); /* OBMC Disable */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4146 if (vo_ver_id == 1) {
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4147 s->vol_sprite_usage = get_bits1(gb); /* vol_sprite_usage */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4148 } else {
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4149 s->vol_sprite_usage = get_bits(gb, 2); /* vol_sprite_usage */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4150 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4151 if(s->vol_sprite_usage==STATIC_SPRITE) printf("Static Sprites not supported\n");
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4152 if(s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE){
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4153 if(s->vol_sprite_usage==STATIC_SPRITE){
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4154 s->sprite_width = get_bits(gb, 13);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4155 skip_bits1(gb); /* marker */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4156 s->sprite_height= get_bits(gb, 13);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4157 skip_bits1(gb); /* marker */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4158 s->sprite_left = get_bits(gb, 13);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4159 skip_bits1(gb); /* marker */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4160 s->sprite_top = get_bits(gb, 13);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4161 skip_bits1(gb); /* marker */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4162 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4163 s->num_sprite_warping_points= get_bits(gb, 6);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4164 s->sprite_warping_accuracy = get_bits(gb, 2);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4165 s->sprite_brightness_change= get_bits1(gb);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4166 if(s->vol_sprite_usage==STATIC_SPRITE)
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4167 s->low_latency_sprite= get_bits1(gb);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4168 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4169 // FIXME sadct disable bit if verid!=1 && shape not rect
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4170
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4171 if (get_bits1(gb) == 1) { /* not_8_bit */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4172 s->quant_precision = get_bits(gb, 4); /* quant_precision */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4173 if(get_bits(gb, 4)!=8) printf("N-bit not supported\n"); /* bits_per_pixel */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4174 if(s->quant_precision!=5) printf("quant precission %d\n", s->quant_precision);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4175 } else {
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4176 s->quant_precision = 5;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4177 }
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4178
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4179 // FIXME a bunch of grayscale shape things
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4180
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4181 if((s->mpeg_quant=get_bits1(gb))){ /* vol_quant_type */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4182 int i, j, v;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4183
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4184 /* load default matrixes */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4185 for(i=0; i<64; i++){
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4186 int j= s->idct_permutation[i];
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4187 v= ff_mpeg4_default_intra_matrix[i];
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4188 s->intra_matrix[j]= v;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4189 s->chroma_intra_matrix[j]= v;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4190
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4191 v= ff_mpeg4_default_non_intra_matrix[i];
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4192 s->inter_matrix[j]= v;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4193 s->chroma_inter_matrix[j]= v;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4194 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4195
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4196 /* load custom intra matrix */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4197 if(get_bits1(gb)){
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4198 int last=0;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4199 for(i=0; i<64; i++){
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4200 v= get_bits(gb, 8);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4201 if(v==0) break;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4202
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4203 last= v;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4204 j= s->idct_permutation[ ff_zigzag_direct[i] ];
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4205 s->intra_matrix[j]= v;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4206 s->chroma_intra_matrix[j]= v;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4207 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4208
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4209 /* replicate last value */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4210 for(; i<64; i++){
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4211 j= s->idct_permutation[ ff_zigzag_direct[i] ];
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4212 s->intra_matrix[j]= v;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4213 s->chroma_intra_matrix[j]= v;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4214 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4215 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4216
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4217 /* load custom non intra matrix */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4218 if(get_bits1(gb)){
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4219 int last=0;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4220 for(i=0; i<64; i++){
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4221 v= get_bits(gb, 8);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4222 if(v==0) break;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4223
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4224 last= v;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4225 j= s->idct_permutation[ ff_zigzag_direct[i] ];
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4226 s->inter_matrix[j]= v;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4227 s->chroma_inter_matrix[j]= v;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4228 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4229
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4230 /* replicate last value */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4231 for(; i<64; i++){
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4232 j= s->idct_permutation[ ff_zigzag_direct[i] ];
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4233 s->inter_matrix[j]= last;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4234 s->chroma_inter_matrix[j]= last;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4235 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4236 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4237
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4238 // FIXME a bunch of grayscale shape things
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4239 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4240
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4241 if(vo_ver_id != 1)
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4242 s->quarter_sample= get_bits1(gb);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4243 else s->quarter_sample=0;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4244
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4245 if(!get_bits1(gb)) printf("Complexity estimation not supported\n");
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4246
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4247 s->resync_marker= !get_bits1(gb); /* resync_marker_disabled */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4248
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4249 s->data_partitioning= get_bits1(gb);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4250 if(s->data_partitioning){
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4251 s->rvlc= get_bits1(gb);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4252 if(s->rvlc){
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4253 printf("reversible vlc not supported\n");
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4254 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4255 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4256
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4257 if(vo_ver_id != 1) {
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4258 s->new_pred= get_bits1(gb);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4259 if(s->new_pred){
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4260 printf("new pred not supported\n");
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4261 skip_bits(gb, 2); /* requested upstream message type */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4262 skip_bits1(gb); /* newpred segment type */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4263 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4264 s->reduced_res_vop= get_bits1(gb);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4265 if(s->reduced_res_vop) printf("reduced resolution VOP not supported\n");
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4266 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4267 else{
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4268 s->new_pred=0;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4269 s->reduced_res_vop= 0;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4270 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4271
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4272 s->scalability= get_bits1(gb);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4273
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4274 if (s->scalability) {
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4275 GetBitContext bak= *gb;
751
cbe316f082bc warning fixes
michaelni
parents: 747
diff changeset
4276 int ref_layer_id;
cbe316f082bc warning fixes
michaelni
parents: 747
diff changeset
4277 int ref_layer_sampling_dir;
cbe316f082bc warning fixes
michaelni
parents: 747
diff changeset
4278 int h_sampling_factor_n;
cbe316f082bc warning fixes
michaelni
parents: 747
diff changeset
4279 int h_sampling_factor_m;
cbe316f082bc warning fixes
michaelni
parents: 747
diff changeset
4280 int v_sampling_factor_n;
cbe316f082bc warning fixes
michaelni
parents: 747
diff changeset
4281 int v_sampling_factor_m;
cbe316f082bc warning fixes
michaelni
parents: 747
diff changeset
4282
cbe316f082bc warning fixes
michaelni
parents: 747
diff changeset
4283 s->hierachy_type= get_bits1(gb);
cbe316f082bc warning fixes
michaelni
parents: 747
diff changeset
4284 ref_layer_id= get_bits(gb, 4);
cbe316f082bc warning fixes
michaelni
parents: 747
diff changeset
4285 ref_layer_sampling_dir= get_bits1(gb);
cbe316f082bc warning fixes
michaelni
parents: 747
diff changeset
4286 h_sampling_factor_n= get_bits(gb, 5);
cbe316f082bc warning fixes
michaelni
parents: 747
diff changeset
4287 h_sampling_factor_m= get_bits(gb, 5);
cbe316f082bc warning fixes
michaelni
parents: 747
diff changeset
4288 v_sampling_factor_n= get_bits(gb, 5);
cbe316f082bc warning fixes
michaelni
parents: 747
diff changeset
4289 v_sampling_factor_m= get_bits(gb, 5);
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4290 s->enhancement_type= get_bits1(gb);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4291
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4292 if( h_sampling_factor_n==0 || h_sampling_factor_m==0
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4293 || v_sampling_factor_n==0 || v_sampling_factor_m==0){
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4294
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4295 // fprintf(stderr, "illegal scalability header (VERY broken encoder), trying to workaround\n");
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4296 s->scalability=0;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4297
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4298 *gb= bak;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4299 }else
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4300 printf("scalability not supported\n");
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4301
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4302 // bin shape stuff FIXME
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4303 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4304 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4305 return 0;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4306 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4307
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4308 static int decode_user_data(MpegEncContext *s, GetBitContext *gb){
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4309 char buf[256];
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4310 int i;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4311 int e;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4312 int ver, build, ver2, ver3;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4313
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4314 buf[0]= show_bits(gb, 8);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4315 for(i=1; i<256; i++){
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4316 buf[i]= show_bits(gb, 16)&0xFF;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4317 if(buf[i]==0) break;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4318 skip_bits(gb, 8);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4319 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4320 buf[255]=0;
761
7f4cc2f6d642 xvid qpel bug autodetect
michaelni
parents: 757
diff changeset
4321
7f4cc2f6d642 xvid qpel bug autodetect
michaelni
parents: 757
diff changeset
4322 /* divx detection */
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4323 e=sscanf(buf, "DivX%dBuild%d", &ver, &build);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4324 if(e!=2)
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4325 e=sscanf(buf, "DivX%db%d", &ver, &build);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4326 if(e==2){
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4327 s->divx_version= ver;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4328 s->divx_build= build;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4329 if(s->picture_number==0){
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4330 printf("This file was encoded with DivX%d Build%d\n", ver, build);
263
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
4331 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4332 }
761
7f4cc2f6d642 xvid qpel bug autodetect
michaelni
parents: 757
diff changeset
4333
7f4cc2f6d642 xvid qpel bug autodetect
michaelni
parents: 757
diff changeset
4334 /* ffmpeg detection */
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4335 e=sscanf(buf, "FFmpeg%d.%d.%db%d", &ver, &ver2, &ver3, &build);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4336 if(e!=4)
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4337 e=sscanf(buf, "FFmpeg v%d.%d.%d / libavcodec build: %d", &ver, &ver2, &ver3, &build);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4338 if(e!=4){
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4339 if(strcmp(buf, "ffmpeg")==0){
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4340 s->ffmpeg_version= 0x000406;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4341 s->lavc_build= 4600;
63
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
4342 }
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4343 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4344 if(e==4){
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4345 s->ffmpeg_version= ver*256*256 + ver2*256 + ver3;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4346 s->lavc_build= build;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4347 if(s->picture_number==0)
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4348 printf("This file was encoded with libavcodec build %d\n", build);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4349 }
761
7f4cc2f6d642 xvid qpel bug autodetect
michaelni
parents: 757
diff changeset
4350
7f4cc2f6d642 xvid qpel bug autodetect
michaelni
parents: 757
diff changeset
4351 /* xvid detection */
7f4cc2f6d642 xvid qpel bug autodetect
michaelni
parents: 757
diff changeset
4352 e=sscanf(buf, "XviD%d", &build);
7f4cc2f6d642 xvid qpel bug autodetect
michaelni
parents: 757
diff changeset
4353 if(e==1){
7f4cc2f6d642 xvid qpel bug autodetect
michaelni
parents: 757
diff changeset
4354 s->xvid_build= build;
7f4cc2f6d642 xvid qpel bug autodetect
michaelni
parents: 757
diff changeset
4355 if(s->picture_number==0)
7f4cc2f6d642 xvid qpel bug autodetect
michaelni
parents: 757
diff changeset
4356 printf("This file was encoded with XviD build %d\n", build);
7f4cc2f6d642 xvid qpel bug autodetect
michaelni
parents: 757
diff changeset
4357 }
7f4cc2f6d642 xvid qpel bug autodetect
michaelni
parents: 757
diff changeset
4358
255
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
4359 //printf("User Data: %s\n", buf);
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4360 return 0;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4361 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4362
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4363 static int decode_vop_header(MpegEncContext *s, GetBitContext *gb){
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4364 int time_incr, time_increment;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4365
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4366 s->pict_type = get_bits(gb, 2) + I_TYPE; /* pict type: I = 0 , P = 1 */
365
fdeec2834c79 there are divx5? encoded files without a userdata section but with b-frames :(
michaelni
parents: 364
diff changeset
4367 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
4368 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
4369 s->low_delay=0;
fdeec2834c79 there are divx5? encoded files without a userdata section but with b-frames :(
michaelni
parents: 364
diff changeset
4370 }
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4371
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
4372 s->partitioned_frame= s->data_partitioning && s->pict_type!=B_TYPE;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
4373 if(s->partitioned_frame)
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
4374 s->decode_mb= mpeg4_decode_partitioned_mb;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
4375 else
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
4376 s->decode_mb= ff_h263_decode_mb;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
4377
662
5a158f0d1981 fixing 1/0 if the headers are incomplete (like what M$ encoder generates)
michaelni
parents: 661
diff changeset
4378 if(s->time_increment_resolution==0){
5a158f0d1981 fixing 1/0 if the headers are incomplete (like what M$ encoder generates)
michaelni
parents: 661
diff changeset
4379 s->time_increment_resolution=1;
5a158f0d1981 fixing 1/0 if the headers are incomplete (like what M$ encoder generates)
michaelni
parents: 661
diff changeset
4380 // fprintf(stderr, "time_increment_resolution is illegal\n");
5a158f0d1981 fixing 1/0 if the headers are incomplete (like what M$ encoder generates)
michaelni
parents: 661
diff changeset
4381 }
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
4382 time_incr=0;
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4383 while (get_bits1(gb) != 0)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4384 time_incr++;
986e461dc072 Initial revision
glantau
parents:
diff changeset
4385
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4386 check_marker(gb, "before time_increment");
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4387 time_increment= get_bits(gb, s->time_increment_bits);
697
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
4388 //printf(" type:%d modulo_time_base:%d increment:%d\n", s->pict_type, time_incr, time_increment);
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
4389 if(s->pict_type!=B_TYPE){
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
4390 s->last_time_base= s->time_base;
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
4391 s->time_base+= time_incr;
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
4392 s->time= s->time_base*s->time_increment_resolution + time_increment;
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
4393 if(s->workaround_bugs&FF_BUG_UMP4){
700
0fb4c66527e1 autodetect UMP4 (by adding a fourcc field to AVCodecContext)
michaelni
parents: 699
diff changeset
4394 if(s->time < s->last_non_b_time){
0fb4c66527e1 autodetect UMP4 (by adding a fourcc field to AVCodecContext)
michaelni
parents: 699
diff changeset
4395 // fprintf(stderr, "header is not mpeg4 compatible, broken encoder, trying to workaround\n");
0fb4c66527e1 autodetect UMP4 (by adding a fourcc field to AVCodecContext)
michaelni
parents: 699
diff changeset
4396 s->time_base++;
0fb4c66527e1 autodetect UMP4 (by adding a fourcc field to AVCodecContext)
michaelni
parents: 699
diff changeset
4397 s->time+= s->time_increment_resolution;
0fb4c66527e1 autodetect UMP4 (by adding a fourcc field to AVCodecContext)
michaelni
parents: 699
diff changeset
4398 }
664
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
4399 }
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
4400 s->pp_time= s->time - s->last_non_b_time;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
4401 s->last_non_b_time= s->time;
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
4402 }else{
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
4403 s->time= (s->last_time_base + time_incr)*s->time_increment_resolution + time_increment;
664
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
4404 s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
4405 if(s->pp_time <=s->pb_time || s->pp_time <= s->pp_time - s->pb_time || s->pp_time<=0){
335
e7e9d9901523 b-frame mpeg4 fix when seeking
michaelni
parents: 333
diff changeset
4406 // printf("messed up order, seeking?, skiping current b frame\n");
e7e9d9901523 b-frame mpeg4 fix when seeking
michaelni
parents: 333
diff changeset
4407 return FRAME_SKIPED;
e7e9d9901523 b-frame mpeg4 fix when seeking
michaelni
parents: 333
diff changeset
4408 }
664
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
4409
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
4410 if(s->t_frame==0) s->t_frame= s->time - s->last_time_base;
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
4411 if(s->t_frame==0) s->t_frame=1; // 1/0 protection
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
4412 //printf("%Ld %Ld %d %d\n", s->last_non_b_time, s->time, s->pp_time, s->t_frame); fflush(stdout);
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
4413 s->pp_field_time= ( ROUNDED_DIV(s->last_non_b_time, s->t_frame)
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
4414 - ROUNDED_DIV(s->last_non_b_time - s->pp_time, s->t_frame))*2;
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
4415 s->pb_field_time= ( ROUNDED_DIV(s->time, s->t_frame)
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
4416 - ROUNDED_DIV(s->last_non_b_time - s->pp_time, s->t_frame))*2;
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
4417 }
654
850098147a3c export pts from stream if available
michaelni
parents: 648
diff changeset
4418
850098147a3c export pts from stream if available
michaelni
parents: 648
diff changeset
4419 s->avctx->pts= s->time*1000LL*1000LL / s->time_increment_resolution;
850098147a3c export pts from stream if available
michaelni
parents: 648
diff changeset
4420
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4421 if(check_marker(gb, "before vop_coded")==0 && s->picture_number==0){
264
28c5c62b1c4c support decoding (with mplayer) of 3 .mp4 files from mphq
michaelni
parents: 263
diff changeset
4422 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
4423 for(s->time_increment_bits++ ;s->time_increment_bits<16; s->time_increment_bits++){
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4424 if(get_bits1(gb)) break;
264
28c5c62b1c4c support decoding (with mplayer) of 3 .mp4 files from mphq
michaelni
parents: 263
diff changeset
4425 }
28c5c62b1c4c support decoding (with mplayer) of 3 .mp4 files from mphq
michaelni
parents: 263
diff changeset
4426 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
4427 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4428 /* vop coded */
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4429 if (get_bits1(gb) != 1){
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4430 printf("vop not coded\n");
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4431 return FRAME_SKIPED;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4432 }
664
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
4433 //printf("time %d %d %d || %Ld %Ld %Ld\n", s->time_increment_bits, s->time_increment_resolution, s->time_base,
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
4434 //s->time, s->last_non_b_time, s->last_non_b_time - s->pp_time);
253
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
4435 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
4436 || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE))) {
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4437 /* rounding type for motion estimation */
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4438 s->no_rounding = get_bits1(gb);
63
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
4439 } else {
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
4440 s->no_rounding = 0;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4441 }
253
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
4442 //FIXME reduced res stuff
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
4443
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
4444 if (s->shape != RECT_SHAPE) {
63
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
4445 if (s->vol_sprite_usage != 1 || s->pict_type != I_TYPE) {
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
4446 int width, height, hor_spat_ref, ver_spat_ref;
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
4447
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4448 width = get_bits(gb, 13);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4449 skip_bits1(gb); /* marker */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4450 height = get_bits(gb, 13);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4451 skip_bits1(gb); /* marker */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4452 hor_spat_ref = get_bits(gb, 13); /* hor_spat_ref */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4453 skip_bits1(gb); /* marker */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4454 ver_spat_ref = get_bits(gb, 13); /* ver_spat_ref */
63
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
4455 }
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4456 skip_bits1(gb); /* change_CR_disable */
63
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
4457
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4458 if (get_bits1(gb) != 0) {
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4459 skip_bits(gb, 8); /* constant_alpha_value */
63
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
4460 }
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
4461 }
253
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
4462 //FIXME complexity estimation stuff
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
4463
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
4464 if (s->shape != BIN_ONLY_SHAPE) {
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
4465 int t;
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4466 t=get_bits(gb, 3); /* intra dc VLC threshold */
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
4467 //printf("threshold %d\n", t);
619
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
4468 if(!s->progressive_sequence){
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4469 s->top_field_first= get_bits1(gb);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4470 s->alternate_scan= get_bits1(gb);
661
a0901e38c564 fixing interlaced mpeg4 decoding
michaelni
parents: 660
diff changeset
4471 }else
a0901e38c564 fixing interlaced mpeg4 decoding
michaelni
parents: 660
diff changeset
4472 s->alternate_scan= 0;
253
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
4473 }
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
4474
718
16dab8296293 fixing custom quantizer matrix decoding
michaelni
parents: 706
diff changeset
4475 if(s->alternate_scan){
16dab8296293 fixing custom quantizer matrix decoding
michaelni
parents: 706
diff changeset
4476 ff_init_scantable(s, &s->inter_scantable , ff_alternate_vertical_scan);
16dab8296293 fixing custom quantizer matrix decoding
michaelni
parents: 706
diff changeset
4477 ff_init_scantable(s, &s->intra_scantable , ff_alternate_vertical_scan);
16dab8296293 fixing custom quantizer matrix decoding
michaelni
parents: 706
diff changeset
4478 ff_init_scantable(s, &s->intra_h_scantable, ff_alternate_vertical_scan);
16dab8296293 fixing custom quantizer matrix decoding
michaelni
parents: 706
diff changeset
4479 ff_init_scantable(s, &s->intra_v_scantable, ff_alternate_vertical_scan);
16dab8296293 fixing custom quantizer matrix decoding
michaelni
parents: 706
diff changeset
4480 } else{
16dab8296293 fixing custom quantizer matrix decoding
michaelni
parents: 706
diff changeset
4481 ff_init_scantable(s, &s->inter_scantable , ff_zigzag_direct);
16dab8296293 fixing custom quantizer matrix decoding
michaelni
parents: 706
diff changeset
4482 ff_init_scantable(s, &s->intra_scantable , ff_zigzag_direct);
16dab8296293 fixing custom quantizer matrix decoding
michaelni
parents: 706
diff changeset
4483 ff_init_scantable(s, &s->intra_h_scantable, ff_alternate_horizontal_scan);
16dab8296293 fixing custom quantizer matrix decoding
michaelni
parents: 706
diff changeset
4484 ff_init_scantable(s, &s->intra_v_scantable, ff_alternate_vertical_scan);
16dab8296293 fixing custom quantizer matrix decoding
michaelni
parents: 706
diff changeset
4485 }
16dab8296293 fixing custom quantizer matrix decoding
michaelni
parents: 706
diff changeset
4486
253
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
4487 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
4488 if(s->num_sprite_warping_points){
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
4489 mpeg4_decode_sprite_trajectory(s);
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
4490 }
253
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
4491 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
4492 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
4493 }
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
4494
253
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
4495 if (s->shape != BIN_ONLY_SHAPE) {
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4496 s->qscale = get_bits(gb, s->quant_precision);
264
28c5c62b1c4c support decoding (with mplayer) of 3 .mp4 files from mphq
michaelni
parents: 263
diff changeset
4497 if(s->qscale==0){
28c5c62b1c4c support decoding (with mplayer) of 3 .mp4 files from mphq
michaelni
parents: 263
diff changeset
4498 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
4499 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
4500 }
63
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
4501
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
4502 if (s->pict_type != I_TYPE) {
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4503 s->f_code = get_bits(gb, 3); /* fcode_for */
264
28c5c62b1c4c support decoding (with mplayer) of 3 .mp4 files from mphq
michaelni
parents: 263
diff changeset
4504 if(s->f_code==0){
28c5c62b1c4c support decoding (with mplayer) of 3 .mp4 files from mphq
michaelni
parents: 263
diff changeset
4505 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
4506 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
4507 }
582
5132a4ee50cd different edge positions fixed with edge emu / dr1
michaelni
parents: 575
diff changeset
4508 }else
5132a4ee50cd different edge positions fixed with edge emu / dr1
michaelni
parents: 575
diff changeset
4509 s->f_code=1;
5132a4ee50cd different edge positions fixed with edge emu / dr1
michaelni
parents: 575
diff changeset
4510
253
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
4511 if (s->pict_type == B_TYPE) {
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4512 s->b_code = get_bits(gb, 3);
582
5132a4ee50cd different edge positions fixed with edge emu / dr1
michaelni
parents: 575
diff changeset
4513 }else
5132a4ee50cd different edge positions fixed with edge emu / dr1
michaelni
parents: 575
diff changeset
4514 s->b_code=1;
664
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
4515 #if 0
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4516 printf("qp:%d fc:%d bc:%d type:%s size:%d pro:%d alt:%d top:%d qpel:%d part:%d resync:%d w:%d a:%d\n",
664
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
4517 s->qscale, s->f_code, s->b_code,
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
4518 s->pict_type == I_TYPE ? "I" : (s->pict_type == P_TYPE ? "P" : (s->pict_type == B_TYPE ? "B" : "S")),
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4519 gb->size,s->progressive_sequence, s->alternate_scan, s->top_field_first,
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4520 s->quarter_sample, s->data_partitioning, s->resync_marker, s->num_sprite_warping_points,
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4521 s->sprite_warping_accuracy);
664
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
4522 #endif
253
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
4523 if(!s->scalability){
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
4524 if (s->shape!=RECT_SHAPE && s->pict_type!=I_TYPE) {
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4525 skip_bits1(gb); // vop shape coding type
253
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
4526 }
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
4527 }else{
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
4528 if(s->enhancement_type){
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4529 int load_backward_shape= get_bits1(gb);
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
4530 if(load_backward_shape){
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
4531 printf("load backward shape isnt supported\n");
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
4532 }
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
4533 }
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4534 skip_bits(gb, 2); //ref_select_code
63
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
4535 }
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
4536 }
346
c2f789fe4945 detecting xvid/divx4/opendivx and set low_delay flag
michaelni
parents: 344
diff changeset
4537 /* 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
4538 // 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
4539 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
4540 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
4541 s->low_delay=1;
c2f789fe4945 detecting xvid/divx4/opendivx and set low_delay flag
michaelni
parents: 344
diff changeset
4542 }
c2f789fe4945 detecting xvid/divx4/opendivx and set low_delay flag
michaelni
parents: 344
diff changeset
4543
255
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
4544 s->picture_number++; // better than pic number==0 allways ;)
346
c2f789fe4945 detecting xvid/divx4/opendivx and set low_delay flag
michaelni
parents: 344
diff changeset
4545
498
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
4546 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
4547 s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
4548
582
5132a4ee50cd different edge positions fixed with edge emu / dr1
michaelni
parents: 575
diff changeset
4549 if(s->divx_version==0 || s->divx_version < 500){
5132a4ee50cd different edge positions fixed with edge emu / dr1
michaelni
parents: 575
diff changeset
4550 s->h_edge_pos= s->width;
5132a4ee50cd different edge positions fixed with edge emu / dr1
michaelni
parents: 575
diff changeset
4551 s->v_edge_pos= s->height;
5132a4ee50cd different edge positions fixed with edge emu / dr1
michaelni
parents: 575
diff changeset
4552 }
63
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
4553 return 0;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4554 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
4555
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4556 /**
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4557 * decode mpeg4 headers
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4558 * @return <0 if no VOP found (or a damaged one)
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4559 * FRAME_SKIPPED if a not coded VOP is found
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4560 * 0 if a VOP is found
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4561 */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4562 int ff_mpeg4_decode_picture_header(MpegEncContext * s, GetBitContext *gb)
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4563 {
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4564 int startcode, v;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4565
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4566 /* search next start code */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4567 align_get_bits(gb);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4568 startcode = 0xff;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4569 for(;;) {
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4570 v = get_bits(gb, 8);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4571 startcode = ((startcode << 8) | v) & 0xffffffff;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4572
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4573 if(get_bits_count(gb) >= gb->size*8){
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4574 if(gb->size==1 && s->divx_version){
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4575 printf("frame skip %d\n", gb->size);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4576 return FRAME_SKIPED; //divx bug
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4577 }else
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4578 return -1; //end of stream
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4579 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4580
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4581 if((startcode&0xFFFFFF00) != 0x100)
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4582 continue; //no startcode
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4583
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4584 switch(startcode){
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4585 case 0x120:
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4586 decode_vol_header(s, gb);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4587 break;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4588 case 0x1b2:
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4589 decode_user_data(s, gb);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4590 break;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4591 case 0x1b6:
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4592 return decode_vop_header(s, gb);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4593 default:
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4594 // printf("startcode %X found\n", startcode);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4595 break;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4596 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4597
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4598 align_get_bits(gb);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4599 startcode = 0xff;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4600 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4601 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4602
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4603 /* don't understand why they choose a different header ! */
986e461dc072 Initial revision
glantau
parents:
diff changeset
4604 int intel_h263_decode_picture_header(MpegEncContext *s)
986e461dc072 Initial revision
glantau
parents:
diff changeset
4605 {
986e461dc072 Initial revision
glantau
parents:
diff changeset
4606 int format;
986e461dc072 Initial revision
glantau
parents:
diff changeset
4607
986e461dc072 Initial revision
glantau
parents:
diff changeset
4608 /* picture header */
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4609 if (get_bits(&s->gb, 22) != 0x20) {
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4610 fprintf(stderr, "Bad picture start code\n");
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4611 return -1;
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4612 }
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4613 s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4614
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4615 if (get_bits1(&s->gb) != 1) {
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4616 fprintf(stderr, "Bad marker\n");
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4617 return -1; /* marker */
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4618 }
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4619 if (get_bits1(&s->gb) != 0) {
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4620 fprintf(stderr, "Bad H263 id\n");
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4621 return -1; /* h263 id */
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4622 }
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
4623 skip_bits1(&s->gb); /* split screen off */
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
4624 skip_bits1(&s->gb); /* camera off */
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
4625 skip_bits1(&s->gb); /* freeze picture release off */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4626
986e461dc072 Initial revision
glantau
parents:
diff changeset
4627 format = get_bits(&s->gb, 3);
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4628 if (format != 7) {
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4629 fprintf(stderr, "Intel H263 free format not supported\n");
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4630 return -1;
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4631 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4632 s->h263_plus = 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
4633
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
4634 s->pict_type = I_TYPE + get_bits1(&s->gb);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4635
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
4636 s->unrestricted_mv = get_bits1(&s->gb);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4637 s->h263_long_vectors = s->unrestricted_mv;
986e461dc072 Initial revision
glantau
parents:
diff changeset
4638
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4639 if (get_bits1(&s->gb) != 0) {
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4640 fprintf(stderr, "SAC not supported\n");
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4641 return -1; /* SAC: off */
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4642 }
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4643 if (get_bits1(&s->gb) != 0) {
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4644 fprintf(stderr, "Advanced Prediction Mode not supported\n");
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4645 return -1; /* advanced prediction mode: off */
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4646 }
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4647 if (get_bits1(&s->gb) != 0) {
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4648 fprintf(stderr, "PB frame mode no supported\n");
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4649 return -1; /* PB frame mode */
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4650 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4651
986e461dc072 Initial revision
glantau
parents:
diff changeset
4652 /* skip unknown header garbage */
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
4653 skip_bits(&s->gb, 41);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4654
986e461dc072 Initial revision
glantau
parents:
diff changeset
4655 s->qscale = get_bits(&s->gb, 5);
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
4656 skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4657
986e461dc072 Initial revision
glantau
parents:
diff changeset
4658 /* PEI */
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
4659 while (get_bits1(&s->gb) != 0) {
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
4660 skip_bits(&s->gb, 8);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4661 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
4662 s->f_code = 1;
770
d1770a34e4f6 segfault fix patch by (Juergen Keil <jk at tools dot de>)
michaelni
parents: 766
diff changeset
4663
d1770a34e4f6 segfault fix patch by (Juergen Keil <jk at tools dot de>)
michaelni
parents: 766
diff changeset
4664 s->y_dc_scale_table=
d1770a34e4f6 segfault fix patch by (Juergen Keil <jk at tools dot de>)
michaelni
parents: 766
diff changeset
4665 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
d1770a34e4f6 segfault fix patch by (Juergen Keil <jk at tools dot de>)
michaelni
parents: 766
diff changeset
4666
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4667 return 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
4668 }
144
cb5dabd00ba2 - Bug fix on inter MCBPC table for inter+q.
pulento
parents: 110
diff changeset
4669