annotate h263.c @ 930:6bcb214d6a17 libavcodec

more debug output
author michaelni
date Tue, 17 Dec 2002 11:25:29 +0000
parents 3b5d9ecedc73
children caa77cd960c0
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
887
19f5b8b7c6d5 fixing aspect
michaelni
parents: 880
diff changeset
123 static void float_aspect_to_info(MpegEncContext * s, float aspect){
19f5b8b7c6d5 fixing aspect
michaelni
parents: 880
diff changeset
124 int i;
19f5b8b7c6d5 fixing aspect
michaelni
parents: 880
diff changeset
125
19f5b8b7c6d5 fixing aspect
michaelni
parents: 880
diff changeset
126 aspect*= s->height/(double)s->width;
19f5b8b7c6d5 fixing aspect
michaelni
parents: 880
diff changeset
127 //printf("%f\n", aspect);
880
1c32039e7215 aspect ratio cleanup
michaelni
parents: 853
diff changeset
128
887
19f5b8b7c6d5 fixing aspect
michaelni
parents: 880
diff changeset
129 if(aspect==0) aspect= 1.0;
19f5b8b7c6d5 fixing aspect
michaelni
parents: 880
diff changeset
130
880
1c32039e7215 aspect ratio cleanup
michaelni
parents: 853
diff changeset
131 ff_float2fraction(&s->aspected_width, &s->aspected_height, aspect, 255);
887
19f5b8b7c6d5 fixing aspect
michaelni
parents: 880
diff changeset
132
19f5b8b7c6d5 fixing aspect
michaelni
parents: 880
diff changeset
133 //printf("%d %d\n", s->aspected_width, s->aspected_height);
19f5b8b7c6d5 fixing aspect
michaelni
parents: 880
diff changeset
134 for(i=1; i<6; i++){
19f5b8b7c6d5 fixing aspect
michaelni
parents: 880
diff changeset
135 if(s->aspected_width == pixel_aspect[i][0] && s->aspected_height== pixel_aspect[i][1]){
19f5b8b7c6d5 fixing aspect
michaelni
parents: 880
diff changeset
136 s->aspect_ratio_info=i;
19f5b8b7c6d5 fixing aspect
michaelni
parents: 880
diff changeset
137 return;
19f5b8b7c6d5 fixing aspect
michaelni
parents: 880
diff changeset
138 }
19f5b8b7c6d5 fixing aspect
michaelni
parents: 880
diff changeset
139 }
880
1c32039e7215 aspect ratio cleanup
michaelni
parents: 853
diff changeset
140
887
19f5b8b7c6d5 fixing aspect
michaelni
parents: 880
diff changeset
141 s->aspect_ratio_info= FF_ASPECT_EXTENDED;
880
1c32039e7215 aspect ratio cleanup
michaelni
parents: 853
diff changeset
142 }
1c32039e7215 aspect ratio cleanup
michaelni
parents: 853
diff changeset
143
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
144 void h263_encode_picture_header(MpegEncContext * s, int picture_number)
986e461dc072 Initial revision
glantau
parents:
diff changeset
145 {
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
146 int format;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
147
986e461dc072 Initial revision
glantau
parents:
diff changeset
148 align_put_bits(&s->pb);
231
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
149
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
150 /* 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
151 s->ptr_lastgob = pbBufPtr(&s->pb);
231
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
152 s->gob_number = 0;
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
153
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
154 put_bits(&s->pb, 22, 0x20); /* PSC */
241
4bb6289eff93 avoid overflow of picturenumber*fps*10000
michaelni
parents: 234
diff changeset
155 put_bits(&s->pb, 8, (((INT64)s->picture_number * 30 * FRAME_RATE_BASE) /
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
156 s->frame_rate) & 0xff);
986e461dc072 Initial revision
glantau
parents:
diff changeset
157
986e461dc072 Initial revision
glantau
parents:
diff changeset
158 put_bits(&s->pb, 1, 1); /* marker */
986e461dc072 Initial revision
glantau
parents:
diff changeset
159 put_bits(&s->pb, 1, 0); /* h263 id */
986e461dc072 Initial revision
glantau
parents:
diff changeset
160 put_bits(&s->pb, 1, 0); /* split screen off */
986e461dc072 Initial revision
glantau
parents:
diff changeset
161 put_bits(&s->pb, 1, 0); /* camera off */
986e461dc072 Initial revision
glantau
parents:
diff changeset
162 put_bits(&s->pb, 1, 0); /* freeze picture release off */
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
163
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
164 format = h263_get_picture_format(s->width, s->height);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
165 if (!s->h263_plus) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
166 /* H.263v1 */
986e461dc072 Initial revision
glantau
parents:
diff changeset
167 put_bits(&s->pb, 3, format);
986e461dc072 Initial revision
glantau
parents:
diff changeset
168 put_bits(&s->pb, 1, (s->pict_type == P_TYPE));
986e461dc072 Initial revision
glantau
parents:
diff changeset
169 /* By now UMV IS DISABLED ON H.263v1, since the restrictions
986e461dc072 Initial revision
glantau
parents:
diff changeset
170 of H.263v1 UMV implies to check the predicted MV after
986e461dc072 Initial revision
glantau
parents:
diff changeset
171 calculation of the current MB to see if we're on the limits */
986e461dc072 Initial revision
glantau
parents:
diff changeset
172 put_bits(&s->pb, 1, 0); /* unrestricted motion vector: off */
986e461dc072 Initial revision
glantau
parents:
diff changeset
173 put_bits(&s->pb, 1, 0); /* SAC: off */
986e461dc072 Initial revision
glantau
parents:
diff changeset
174 put_bits(&s->pb, 1, 0); /* advanced prediction mode: off */
986e461dc072 Initial revision
glantau
parents:
diff changeset
175 put_bits(&s->pb, 1, 0); /* not PB frame */
986e461dc072 Initial revision
glantau
parents:
diff changeset
176 put_bits(&s->pb, 5, s->qscale);
986e461dc072 Initial revision
glantau
parents:
diff changeset
177 put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */
986e461dc072 Initial revision
glantau
parents:
diff changeset
178 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
179 /* H.263v2 */
986e461dc072 Initial revision
glantau
parents:
diff changeset
180 /* H.263 Plus PTYPE */
986e461dc072 Initial revision
glantau
parents:
diff changeset
181 put_bits(&s->pb, 3, 7);
986e461dc072 Initial revision
glantau
parents:
diff changeset
182 put_bits(&s->pb,3,1); /* Update Full Extended PTYPE */
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
183 if (format == 7)
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
184 put_bits(&s->pb,3,6); /* Custom Source Format */
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
185 else
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
186 put_bits(&s->pb, 3, format);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
187
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
188 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
189 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
190 put_bits(&s->pb, 1, s->umvplus); /* Unrestricted Motion Vector */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
191 put_bits(&s->pb,1,0); /* SAC: off */
986e461dc072 Initial revision
glantau
parents:
diff changeset
192 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
193 put_bits(&s->pb,1,s->h263_aic); /* Advanced Intra Coding */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
194 put_bits(&s->pb,1,0); /* Deblocking Filter: off */
986e461dc072 Initial revision
glantau
parents:
diff changeset
195 put_bits(&s->pb,1,0); /* Slice Structured: off */
986e461dc072 Initial revision
glantau
parents:
diff changeset
196 put_bits(&s->pb,1,0); /* Reference Picture Selection: off */
986e461dc072 Initial revision
glantau
parents:
diff changeset
197 put_bits(&s->pb,1,0); /* Independent Segment Decoding: off */
986e461dc072 Initial revision
glantau
parents:
diff changeset
198 put_bits(&s->pb,1,0); /* Alternative Inter VLC: off */
986e461dc072 Initial revision
glantau
parents:
diff changeset
199 put_bits(&s->pb,1,0); /* Modified Quantization: off */
986e461dc072 Initial revision
glantau
parents:
diff changeset
200 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
986e461dc072 Initial revision
glantau
parents:
diff changeset
201 put_bits(&s->pb,3,0); /* Reserved */
986e461dc072 Initial revision
glantau
parents:
diff changeset
202
986e461dc072 Initial revision
glantau
parents:
diff changeset
203 put_bits(&s->pb, 3, s->pict_type == P_TYPE);
986e461dc072 Initial revision
glantau
parents:
diff changeset
204
986e461dc072 Initial revision
glantau
parents:
diff changeset
205 put_bits(&s->pb,1,0); /* Reference Picture Resampling: off */
986e461dc072 Initial revision
glantau
parents:
diff changeset
206 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
207 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
208 s->no_rounding = 0;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
209 else
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
210 s->no_rounding ^= 1;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
211 put_bits(&s->pb,1,s->no_rounding); /* Rounding Type */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
212 put_bits(&s->pb,2,0); /* Reserved */
986e461dc072 Initial revision
glantau
parents:
diff changeset
213 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
986e461dc072 Initial revision
glantau
parents:
diff changeset
214
986e461dc072 Initial revision
glantau
parents:
diff changeset
215 /* This should be here if PLUSPTYPE */
986e461dc072 Initial revision
glantau
parents:
diff changeset
216 put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */
986e461dc072 Initial revision
glantau
parents:
diff changeset
217
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
218 if (format == 7) {
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
219 /* Custom Picture Format (CPFMT) */
887
19f5b8b7c6d5 fixing aspect
michaelni
parents: 880
diff changeset
220 float_aspect_to_info(s, s->avctx->aspect_ratio);
880
1c32039e7215 aspect ratio cleanup
michaelni
parents: 853
diff changeset
221
1c32039e7215 aspect ratio cleanup
michaelni
parents: 853
diff changeset
222 put_bits(&s->pb,4,s->aspect_ratio_info);
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
223 put_bits(&s->pb,9,(s->width >> 2) - 1);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
224 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
225 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
226 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
227 {
b4bddbde44f3 aspect (ext. par too) support for h263 and mpeg4 (inc. build becouse of new vars)
al3x
parents: 667
diff changeset
228 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
229 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
230 }
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
231 }
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
232
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
233 /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
79
82e579c37bc3 Moved some H.263+ variables to MpegEncContext to be thread-safe.
pulento
parents: 78
diff changeset
234 if (s->umvplus)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
235 put_bits(&s->pb,1,1); /* Limited according tables of Annex D */
986e461dc072 Initial revision
glantau
parents:
diff changeset
236 put_bits(&s->pb, 5, s->qscale);
986e461dc072 Initial revision
glantau
parents:
diff changeset
237 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
238
986e461dc072 Initial revision
glantau
parents:
diff changeset
239 put_bits(&s->pb, 1, 0); /* no PEI */
498
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
240
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
241 if(s->h263_aic){
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
242 s->y_dc_scale_table=
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
243 s->c_dc_scale_table= h263_aic_dc_scale_table;
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
244 }else{
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
245 s->y_dc_scale_table=
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
246 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
247 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
248 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
249
766
8d36b35a7e6e slice encoding cleanup
michaelni
parents: 761
diff changeset
250 /**
8d36b35a7e6e slice encoding cleanup
michaelni
parents: 761
diff changeset
251 * Encodes a group of blocks header.
8d36b35a7e6e slice encoding cleanup
michaelni
parents: 761
diff changeset
252 */
162
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
253 int h263_encode_gob_header(MpegEncContext * s, int mb_line)
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
254 {
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
255 align_put_bits(&s->pb);
231
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
256 flush_put_bits(&s->pb);
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
257 /* Call the RTP callback to send the last GOB */
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
258 if (s->rtp_callback) {
766
8d36b35a7e6e slice encoding cleanup
michaelni
parents: 761
diff changeset
259 int pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;
231
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
260 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
261 }
162
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
262 put_bits(&s->pb, 17, 1); /* GBSC */
231
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
263 s->gob_number = mb_line / s->gob_index;
162
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
264 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
265 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
266 put_bits(&s->pb, 5, s->qscale); /* GQUANT */
231
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
267 //fprintf(stderr,"\nGOB: %2d size: %d", s->gob_number - 1, pdif);
766
8d36b35a7e6e slice encoding cleanup
michaelni
parents: 761
diff changeset
268 return 0;
162
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
269 }
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
270
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
271 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
272 {
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
273 int score0=0, score1=0;
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
274 int i, n;
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
275 int8_t * const qscale_table= s->current_picture.qscale_table;
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
276
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
277 for(n=0; n<6; n++){
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
278 INT16 *ac_val, *ac_val1;
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
279
266
252444e5259b optimization
michaelni
parents: 265
diff changeset
280 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
281 ac_val1= ac_val;
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
282 if(dir[n]){
692
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
283 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
284 /* top prediction */
266
252444e5259b optimization
michaelni
parents: 265
diff changeset
285 ac_val-= s->block_wrap[n]*16;
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
286 if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){
692
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
287 /* same qscale */
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
288 for(i=1; i<8; i++){
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
289 const int level= block[n][s->idct_permutation[i ]];
692
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
290 score0+= ABS(level);
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
291 score1+= ABS(level - ac_val[i+8]);
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
292 ac_val1[i ]= block[n][s->idct_permutation[i<<3]];
692
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
293 ac_val1[i+8]= level;
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
294 }
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
295 }else{
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
296 /* different qscale, we must rescale */
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
297 for(i=1; i<8; i++){
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
298 const int level= block[n][s->idct_permutation[i ]];
692
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
299 score0+= ABS(level);
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
300 score1+= ABS(level - ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale));
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
301 ac_val1[i ]= block[n][s->idct_permutation[i<<3]];
692
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
302 ac_val1[i+8]= level;
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
303 }
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
304 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
305 }else{
692
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
306 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
307 /* left prediction */
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
308 ac_val-= 16;
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
309 if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){
692
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
310 /* same qscale */
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
311 for(i=1; i<8; i++){
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
312 const int level= block[n][s->idct_permutation[i<<3]];
692
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
313 score0+= ABS(level);
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
314 score1+= ABS(level - ac_val[i]);
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
315 ac_val1[i ]= level;
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
316 ac_val1[i+8]= block[n][s->idct_permutation[i ]];
692
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
317 }
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
318 }else{
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
319 /* different qscale, we must rescale */
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
320 for(i=1; i<8; i++){
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
321 const int level= block[n][s->idct_permutation[i<<3]];
692
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
322 score0+= ABS(level);
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
323 score1+= ABS(level - ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale));
692
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
324 ac_val1[i ]= level;
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
325 ac_val1[i+8]= block[n][s->idct_permutation[i ]];
692
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
326 }
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
327 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
328 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
329 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
330
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
331 return score0 > score1 ? 1 : 0;
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
332 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
333
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
334 /**
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
335 * 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
336 */
695
3525da287ee2 adaptive quantization for h263
michaelni
parents: 692
diff changeset
337 void ff_clean_h263_qscales(MpegEncContext *s){
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
338 int i;
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
339 int8_t * const qscale_table= s->current_picture.qscale_table;
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
340
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
341 for(i=1; i<s->mb_num; i++){
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
342 if(qscale_table[i] - qscale_table[i-1] >2)
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
343 qscale_table[i]= qscale_table[i-1]+2;
690
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 for(i=s->mb_num-2; i>=0; i--){
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
346 if(qscale_table[i] - qscale_table[i+1] >2)
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
347 qscale_table[i]= qscale_table[i+1]+2;
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
348 }
695
3525da287ee2 adaptive quantization for h263
michaelni
parents: 692
diff changeset
349 }
3525da287ee2 adaptive quantization for h263
michaelni
parents: 692
diff changeset
350
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
351 /**
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
352 * 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
353 */
695
3525da287ee2 adaptive quantization for h263
michaelni
parents: 692
diff changeset
354 void ff_clean_mpeg4_qscales(MpegEncContext *s){
3525da287ee2 adaptive quantization for h263
michaelni
parents: 692
diff changeset
355 int i;
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
356 int8_t * const qscale_table= s->current_picture.qscale_table;
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
357
695
3525da287ee2 adaptive quantization for h263
michaelni
parents: 692
diff changeset
358 ff_clean_h263_qscales(s);
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
359
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
360 for(i=1; i<s->mb_num; i++){
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
361 if(qscale_table[i] != qscale_table[i-1] && (s->mb_type[i]&MB_TYPE_INTER4V)){
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
362 s->mb_type[i]&= ~MB_TYPE_INTER4V;
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
363 s->mb_type[i]|= MB_TYPE_INTER;
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
364 }
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
365 }
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
366
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
367 if(s->pict_type== B_TYPE){
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
368 int odd=0;
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
369 /* 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
370 for the actual adaptive quantization */
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 for(i=0; i<s->mb_num; i++){
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
373 odd += qscale_table[i]&1;
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
374 }
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
375
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
376 if(2*odd > s->mb_num) odd=1;
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
377 else odd=0;
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
378
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
379 for(i=0; i<s->mb_num; i++){
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
380 if((qscale_table[i]&1) != odd)
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
381 qscale_table[i]++;
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
382 if(qscale_table[i] > 31)
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
383 qscale_table[i]= 31;
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
384 }
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
385
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
386 for(i=1; i<s->mb_num; i++){
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
387 if(qscale_table[i] != qscale_table[i-1] && (s->mb_type[i]&MB_TYPE_DIRECT)){
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
388 s->mb_type[i]&= ~MB_TYPE_DIRECT;
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
389 s->mb_type[i]|= MB_TYPE_BIDIR;
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
390 }
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
391 }
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
392 }
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
393 }
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
394
815
78accc54493b put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents: 770
diff changeset
395 #ifdef CONFIG_ENCODERS
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
396 void mpeg4_encode_mb(MpegEncContext * s,
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
397 DCTELEM block[6][64],
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
398 int motion_x, int motion_y)
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
399 {
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
400 int cbpc, cbpy, i, pred_x, pred_y;
286
91f7c38f5f37 statistics for 2-pass encoding
michaelni
parents: 285
diff changeset
401 int bits;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
402 PutBitContext * const pb2 = s->data_partitioning ? &s->pb2 : &s->pb;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
403 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
404 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
405 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
406 const int dquant_code[5]= {1,0,9,2,3};
162
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
407
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
408 // 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
409 if (!s->mb_intra) {
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
410 /* compute cbp */
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
411 int cbp = 0;
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
412 for (i = 0; i < 6; i++) {
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
413 if (s->block_last_index[i] >= 0)
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
414 cbp |= 1 << (5 - i);
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
415 }
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
416
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
417 if(s->pict_type==B_TYPE){
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
418 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
419 int mb_type= mb_type_table[s->mv_dir];
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 if(s->mb_x==0){
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
422 s->last_mv[0][0][0]=
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
423 s->last_mv[0][0][1]=
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
424 s->last_mv[1][0][0]=
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
425 s->last_mv[1][0][1]= 0;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
426 }
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
427
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
428 assert(s->dquant>=-2 && s->dquant<=2);
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
429 assert((s->dquant&1)==0);
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
430 assert(mb_type>=0);
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
431
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
432 /* nothing to do if this MB was skiped in the next P Frame */
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
433 if(s->next_picture.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
434 s->skip_count++;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
435 s->mv[0][0][0]=
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
436 s->mv[0][0][1]=
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
437 s->mv[1][0][0]=
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
438 s->mv[1][0][1]= 0;
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
439 s->mv_dir= MV_DIR_FORWARD; //doesnt matter
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
440 s->qscale -= s->dquant;
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
441 // s->mb_skiped=1;
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
442
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
443 return;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
444 }
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
445
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
446 if ((cbp | motion_x | motion_y | mb_type) ==0) {
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
447 /* direct MB with MV={0,0} */
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
448 assert(s->dquant==0);
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
449
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
450 put_bits(&s->pb, 1, 1); /* mb not coded modb1=1 */
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
451
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
452 if(interleaved_stats){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
453 s->misc_bits++;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
454 s->last_bits++;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
455 }
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
456 s->skip_count++;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
457 return;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
458 }
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
459
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
460 put_bits(&s->pb, 1, 0); /* mb coded modb1=0 */
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
461 put_bits(&s->pb, 1, cbp ? 0 : 1); /* modb2 */ //FIXME merge
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
462 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
463 if(cbp) put_bits(&s->pb, 6, cbp);
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
464
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
465 if(cbp && mb_type){
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
466 if(s->dquant)
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
467 put_bits(&s->pb, 2, (s->dquant>>2)+3);
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
468 else
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
469 put_bits(&s->pb, 1, 0);
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
470 }else
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
471 s->qscale -= s->dquant;
697
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
472
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
473 if(!s->progressive_sequence){
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
474 if(cbp)
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
475 put_bits(&s->pb, 1, s->interlaced_dct);
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
476 if(mb_type) // not diect mode
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
477 put_bits(&s->pb, 1, 0); // no interlaced ME yet
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
478 }
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
479
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
480 if(interleaved_stats){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
481 bits= get_bit_count(&s->pb);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
482 s->misc_bits+= bits - s->last_bits;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
483 s->last_bits=bits;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
484 }
295
6622b0fd036c mpeg4 4MV encoding
michaelni
parents: 294
diff changeset
485
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
486 switch(mb_type)
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
487 {
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
488 case 0: /* direct */
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
489 h263_encode_motion(s, motion_x, 1);
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
490 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
491 s->b_count++;
e47fa3e3f2d5 statistics for forw & back p-MBs instead of just one counter for both
michaelni
parents: 654
diff changeset
492 s->f_count++;
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
493 break;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
494 case 1: /* bidir */
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
495 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
496 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
497 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
498 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
499 s->last_mv[0][0][0]= s->mv[0][0][0];
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
500 s->last_mv[0][0][1]= s->mv[0][0][1];
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
501 s->last_mv[1][0][0]= s->mv[1][0][0];
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
502 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
503 s->b_count++;
e47fa3e3f2d5 statistics for forw & back p-MBs instead of just one counter for both
michaelni
parents: 654
diff changeset
504 s->f_count++;
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
505 break;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
506 case 2: /* backward */
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
507 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
508 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
509 s->last_mv[1][0][0]= motion_x;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
510 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
511 s->b_count++;
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
512 break;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
513 case 3: /* forward */
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
514 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
515 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
516 s->last_mv[0][0][0]= motion_x;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
517 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
518 s->f_count++;
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
519 break;
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
520 default:
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
521 printf("unknown mb type\n");
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
522 return;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
523 }
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
524
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
525 if(interleaved_stats){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
526 bits= get_bit_count(&s->pb);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
527 s->mv_bits+= bits - s->last_bits;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
528 s->last_bits=bits;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
529 }
295
6622b0fd036c mpeg4 4MV encoding
michaelni
parents: 294
diff changeset
530
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
531 /* encode each block */
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
532 for (i = 0; i < 6; i++) {
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
533 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
534 }
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
535
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
536 if(interleaved_stats){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
537 bits= get_bit_count(&s->pb);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
538 s->p_tex_bits+= bits - s->last_bits;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
539 s->last_bits=bits;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
540 }
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
541 }else{ /* s->pict_type==B_TYPE */
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
542 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
543 /* 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
544 why didnt they just compress the skip-mb bits instead of reusing them ?! */
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
545 if(s->max_b_frames>0){
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
546 int i;
364
6b6332e7008a segfault fix for b-frame encoding with height%16!=0
michaelni
parents: 360
diff changeset
547 int x,y, offset;
6b6332e7008a segfault fix for b-frame encoding with height%16!=0
michaelni
parents: 360
diff changeset
548 uint8_t *p_pic;
6b6332e7008a segfault fix for b-frame encoding with height%16!=0
michaelni
parents: 360
diff changeset
549
6b6332e7008a segfault fix for b-frame encoding with height%16!=0
michaelni
parents: 360
diff changeset
550 x= s->mb_x*16;
6b6332e7008a segfault fix for b-frame encoding with height%16!=0
michaelni
parents: 360
diff changeset
551 y= s->mb_y*16;
6b6332e7008a segfault fix for b-frame encoding with height%16!=0
michaelni
parents: 360
diff changeset
552 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
553 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
554
6b6332e7008a segfault fix for b-frame encoding with height%16!=0
michaelni
parents: 360
diff changeset
555 offset= x + y*s->linesize;
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
556 p_pic= s->new_picture.data[0] + offset;
364
6b6332e7008a segfault fix for b-frame encoding with height%16!=0
michaelni
parents: 360
diff changeset
557
331
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
558 s->mb_skiped=1;
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
559 for(i=0; i<s->max_b_frames; i++){
339
b743a6bbab25 segfault fix
michaelni
parents: 336
diff changeset
560 uint8_t *b_pic;
b743a6bbab25 segfault fix
michaelni
parents: 336
diff changeset
561 int diff;
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
562 Picture *pic= s->reordered_input_picture[i+1];
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
563
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
564 if(pic==NULL || pic->pict_type!=B_TYPE) break;
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
565
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
566 b_pic= pic->data[0] + offset + 16; //FIXME +16
853
eacc2dd8fd9d * using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents: 847
diff changeset
567 diff= s->dsp.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
568 if(diff>s->qscale*70){ //FIXME check that 70 is optimal
331
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
569 s->mb_skiped=0;
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
570 break;
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
571 }
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
572 }
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
573 }else
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
574 s->mb_skiped=1;
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
575
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
576 if(s->mb_skiped==1){
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
577 /* skip macroblock */
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
578 put_bits(&s->pb, 1, 1);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
579
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
580 if(interleaved_stats){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
581 s->misc_bits++;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
582 s->last_bits++;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
583 }
331
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
584 s->skip_count++;
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
585 return;
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
586 }
295
6622b0fd036c mpeg4 4MV encoding
michaelni
parents: 294
diff changeset
587 }
364
6b6332e7008a segfault fix for b-frame encoding with height%16!=0
michaelni
parents: 360
diff changeset
588
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
589 put_bits(&s->pb, 1, 0); /* mb coded */
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
590 if(s->mv_type==MV_TYPE_16X16){
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
591 cbpc = cbp & 3;
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
592 if(s->dquant) cbpc+= 8;
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
593 put_bits(&s->pb,
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
594 inter_MCBPC_bits[cbpc],
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
595 inter_MCBPC_code[cbpc]);
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
596
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
597 cbpy = cbp >> 2;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
598 cbpy ^= 0xf;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
599 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
600 if(s->dquant)
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
601 put_bits(pb2, 2, dquant_code[s->dquant+2]);
697
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
602
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
603 if(!s->progressive_sequence){
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
604 if(cbp)
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
605 put_bits(pb2, 1, s->interlaced_dct);
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
606 put_bits(pb2, 1, 0); // no interlaced ME yet
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
607 }
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
608
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
609 if(interleaved_stats){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
610 bits= get_bit_count(&s->pb);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
611 s->misc_bits+= bits - s->last_bits;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
612 s->last_bits=bits;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
613 }
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
614
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
615 /* motion vectors: 16x16 mode */
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
616 h263_pred_motion(s, 0, &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, motion_x - pred_x, s->f_code);
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
619 h263_encode_motion(s, motion_y - pred_y, s->f_code);
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
620 }else{
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
621 cbpc = (cbp & 3)+16;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
622 put_bits(&s->pb,
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
623 inter_MCBPC_bits[cbpc],
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
624 inter_MCBPC_code[cbpc]);
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
625 cbpy = cbp >> 2;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
626 cbpy ^= 0xf;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
627 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
628
757
d031d1575ceb fixing interlaced dct with 4mv
michaelni
parents: 753
diff changeset
629 if(!s->progressive_sequence){
d031d1575ceb fixing interlaced dct with 4mv
michaelni
parents: 753
diff changeset
630 if(cbp)
d031d1575ceb fixing interlaced dct with 4mv
michaelni
parents: 753
diff changeset
631 put_bits(pb2, 1, s->interlaced_dct);
d031d1575ceb fixing interlaced dct with 4mv
michaelni
parents: 753
diff changeset
632 }
d031d1575ceb fixing interlaced dct with 4mv
michaelni
parents: 753
diff changeset
633
453
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->misc_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 }
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
639
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
640 for(i=0; i<4; i++){
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
641 /* motion vectors: 8x8 mode*/
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
642 h263_pred_motion(s, i, &pred_x, &pred_y);
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
643
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
644 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
645 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
646 }
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
647 }
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
648
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
649 if(interleaved_stats){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
650 bits= get_bit_count(&s->pb);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
651 s->mv_bits+= bits - s->last_bits;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
652 s->last_bits=bits;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
653 }
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
654
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
655 /* encode each block */
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
656 for (i = 0; i < 6; i++) {
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
657 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
658 }
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
659
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
660 if(interleaved_stats){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
661 bits= get_bit_count(&s->pb);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
662 s->p_tex_bits+= bits - s->last_bits;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
663 s->last_bits=bits;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
664 }
656
e47fa3e3f2d5 statistics for forw & back p-MBs instead of just one counter for both
michaelni
parents: 654
diff changeset
665 s->f_count++;
295
6622b0fd036c mpeg4 4MV encoding
michaelni
parents: 294
diff changeset
666 }
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
667 } else {
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
668 int cbp;
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
669 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
670 int dir[6]; //prediction direction
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
671 int zigzag_last_index[6];
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
672 UINT8 *scan_table[6];
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
673
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
674 for(i=0; i<6; i++){
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
675 const int level= block[i][0];
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
676 UINT16 *dc_ptr;
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
677
498
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
678 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
679 if (i < 4) {
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
680 *dc_ptr = level * s->y_dc_scale;
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
681 } else {
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
682 *dc_ptr = level * s->c_dc_scale;
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
683 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
684 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
685
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
686 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
687
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
688 if(s->ac_pred){
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
689 for(i=0; i<6; i++){
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
690 UINT8 *st;
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
691 int last_index;
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
692
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
693 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
694 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
695 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
696
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
697 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
698 if(block[i][st[last_index]]) break;
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
699 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
700 s->block_last_index[i]= last_index;
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
701 scan_table[i]= st;
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
702 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
703 }else{
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
704 for(i=0; i<6; i++)
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
705 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
706 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
707
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
708 /* compute cbp */
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
709 cbp = 0;
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
710 for (i = 0; i < 6; i++) {
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
711 if (s->block_last_index[i] >= 1)
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
712 cbp |= 1 << (5 - i);
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
713 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
714
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
715 cbpc = cbp & 3;
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
716 if (s->pict_type == I_TYPE) {
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
717 if(s->dquant) cbpc+=4;
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
718 put_bits(&s->pb,
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
719 intra_MCBPC_bits[cbpc],
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
720 intra_MCBPC_code[cbpc]);
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
721 } else {
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
722 if(s->dquant) cbpc+=8;
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
723 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
724 put_bits(&s->pb,
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
725 inter_MCBPC_bits[cbpc + 4],
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
726 inter_MCBPC_code[cbpc + 4]);
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
727 }
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
728 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
729 cbpy = cbp >> 2;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
730 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
731 if(s->dquant)
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
732 put_bits(dc_pb, 2, dquant_code[s->dquant+2]);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
733
697
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
734 if(!s->progressive_sequence){
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
735 put_bits(dc_pb, 1, s->interlaced_dct);
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
736 }
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
737
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
738 if(interleaved_stats){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
739 bits= get_bit_count(&s->pb);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
740 s->misc_bits+= bits - s->last_bits;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
741 s->last_bits=bits;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
742 }
286
91f7c38f5f37 statistics for 2-pass encoding
michaelni
parents: 285
diff changeset
743
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
744 /* encode each block */
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
745 for (i = 0; i < 6; i++) {
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
746 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
747 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
748
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
749 if(interleaved_stats){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
750 bits= get_bit_count(&s->pb);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
751 s->i_tex_bits+= bits - s->last_bits;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
752 s->last_bits=bits;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
753 }
286
91f7c38f5f37 statistics for 2-pass encoding
michaelni
parents: 285
diff changeset
754 s->i_count++;
91f7c38f5f37 statistics for 2-pass encoding
michaelni
parents: 285
diff changeset
755
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
756 /* 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
757 if(s->ac_pred){
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
758 for(i=0; i<6; i++){
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
759 int j;
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
760 INT16 *ac_val;
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
761
266
252444e5259b optimization
michaelni
parents: 265
diff changeset
762 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
763
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
764 if(dir[i]){
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
765 for(j=1; j<8; j++)
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
766 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
767 }else{
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
768 for(j=1; j<8; j++)
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
769 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
770 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
771 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
772 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
773 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
774 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
775 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
776
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
777 void h263_encode_mb(MpegEncContext * s,
986e461dc072 Initial revision
glantau
parents:
diff changeset
778 DCTELEM block[6][64],
986e461dc072 Initial revision
glantau
parents:
diff changeset
779 int motion_x, int motion_y)
986e461dc072 Initial revision
glantau
parents:
diff changeset
780 {
986e461dc072 Initial revision
glantau
parents:
diff changeset
781 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
782 INT16 pred_dc;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
783 INT16 rec_intradc[6];
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
784 UINT16 *dc_ptr[6];
695
3525da287ee2 adaptive quantization for h263
michaelni
parents: 692
diff changeset
785 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
786
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
787 //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
788 if (!s->mb_intra) {
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
789 /* compute cbp */
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
790 cbp = 0;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
791 for (i = 0; i < 6; i++) {
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
792 if (s->block_last_index[i] >= 0)
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
793 cbp |= 1 << (5 - i);
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
794 }
695
3525da287ee2 adaptive quantization for h263
michaelni
parents: 692
diff changeset
795 if ((cbp | motion_x | motion_y | s->dquant) == 0) {
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
796 /* skip macroblock */
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
797 put_bits(&s->pb, 1, 1);
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
798 return;
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 put_bits(&s->pb, 1, 0); /* mb coded */
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
801 cbpc = cbp & 3;
695
3525da287ee2 adaptive quantization for h263
michaelni
parents: 692
diff changeset
802 if(s->dquant) cbpc+= 8;
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
803 put_bits(&s->pb,
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
804 inter_MCBPC_bits[cbpc],
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
805 inter_MCBPC_code[cbpc]);
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
806 cbpy = cbp >> 2;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
807 cbpy ^= 0xf;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
808 put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
695
3525da287ee2 adaptive quantization for h263
michaelni
parents: 692
diff changeset
809 if(s->dquant)
3525da287ee2 adaptive quantization for h263
michaelni
parents: 692
diff changeset
810 put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
811
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
812 /* motion vectors: 16x16 mode only now */
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
813 h263_pred_motion(s, 0, &pred_x, &pred_y);
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
814
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
815 if (!s->umvplus) {
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
816 h263_encode_motion(s, motion_x - pred_x, s->f_code);
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
817 h263_encode_motion(s, motion_y - pred_y, s->f_code);
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
818 }
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
819 else {
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
820 h263p_encode_umotion(s, motion_x - pred_x);
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
821 h263p_encode_umotion(s, motion_y - pred_y);
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
822 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
823 /* To prevent Start Code emulation */
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
824 put_bits(&s->pb,1,1);
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
825 }
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
826 } else {
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
827 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
828
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
829 cbp = 0;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
830 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
831 /* Predict DC */
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
832 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
833 INT16 level = block[i][0];
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
834
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
835 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
836 level -= pred_dc;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
837 /* Quant */
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
838 if (level < 0)
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
839 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
840 else
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
841 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
842
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
843 /* AIC can change CBP */
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
844 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
845 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
846 else if (level < -127)
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
847 level = -127;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
848 else if (level > 127)
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
849 level = 127;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
850
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
851 block[i][0] = level;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
852 /* Reconstruction */
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
853 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
854 /* Oddify */
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
855 rec_intradc[i] |= 1;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
856 //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
857 // rec_intradc[i]++;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
858 /* Clipping */
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
859 if (rec_intradc[i] < 0)
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
860 rec_intradc[i] = 0;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
861 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
862 rec_intradc[i] = 2047;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
863
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
864 /* Update AC/DC tables */
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
865 *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
866 }
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
867 /* compute cbp */
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
868 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
869 cbp |= 1 << (5 - i);
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
870 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
871
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
872 cbpc = cbp & 3;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
873 if (s->pict_type == I_TYPE) {
695
3525da287ee2 adaptive quantization for h263
michaelni
parents: 692
diff changeset
874 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
875 put_bits(&s->pb,
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
876 intra_MCBPC_bits[cbpc],
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
877 intra_MCBPC_code[cbpc]);
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
878 } else {
695
3525da287ee2 adaptive quantization for h263
michaelni
parents: 692
diff changeset
879 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
880 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
881 put_bits(&s->pb,
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
882 inter_MCBPC_bits[cbpc + 4],
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
883 inter_MCBPC_code[cbpc + 4]);
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
884 }
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
885 if (s->h263_aic) {
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
886 /* 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
887 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
888 }
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
889 cbpy = cbp >> 2;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
890 put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
695
3525da287ee2 adaptive quantization for h263
michaelni
parents: 692
diff changeset
891 if(s->dquant)
3525da287ee2 adaptive quantization for h263
michaelni
parents: 692
diff changeset
892 put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
893 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
894
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
895 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
896 /* encode each block */
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 293
diff changeset
897 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
898
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
899 /* Update INTRADC for decoding */
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
900 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
901 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
902
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
903 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
904 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
905 }
815
78accc54493b put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents: 770
diff changeset
906 #endif
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
907
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
908 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
909 {
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
910 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
911 INT16 *dc_val, *ac_val;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
912
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
913 /* find prediction */
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
914 if (n < 4) {
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
915 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
916 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
917 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
918 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
919 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
920 scale = s->y_dc_scale;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
921 } else {
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
922 x = s->mb_x + 1;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
923 y = s->mb_y + 1;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
924 wrap = s->mb_width + 2;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
925 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
926 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
927 scale = s->c_dc_scale;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
928 }
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
929 /* B C
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
930 * A X
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
931 */
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
932 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
933 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
934
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
935 /* No prediction outside GOB boundary */
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
936 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
937 c = 1024;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
938 pred_dc = 1024;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
939 /* just DC prediction */
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
940 if (a != 1024 && c != 1024)
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
941 pred_dc = (a + c) >> 1;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
942 else if (a != 1024)
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
943 pred_dc = a;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
944 else
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
945 pred_dc = c;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
946
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
947 /* we assume pred is positive */
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
948 //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
949 *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
950 return pred_dc;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
951 }
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
952
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
953
249
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
954 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
955 {
249
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
956 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
957 INT16 *dc_val, *ac_val, *ac_val1;
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
958
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
959 /* find prediction */
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
960 if (n < 4) {
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
961 x = 2 * s->mb_x + 1 + (n & 1);
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
962 y = 2 * s->mb_y + 1 + ((n & 2) >> 1);
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
963 wrap = s->mb_width * 2 + 2;
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
964 dc_val = s->dc_val[0];
249
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
965 ac_val = s->ac_val[0][0];
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
966 scale = s->y_dc_scale;
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
967 } else {
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
968 x = s->mb_x + 1;
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
969 y = s->mb_y + 1;
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
970 wrap = s->mb_width + 2;
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
971 dc_val = s->dc_val[n - 4 + 1];
249
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
972 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
973 scale = s->c_dc_scale;
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
974 }
249
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
975
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
976 ac_val += ((y) * wrap + (x)) * 16;
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
977 ac_val1 = ac_val;
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
978
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
979 /* B C
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
980 * A X
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 a = dc_val[(x - 1) + (y) * wrap];
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
983 c = dc_val[(x) + (y - 1) * wrap];
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
984
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
985 /* No prediction outside GOB boundary */
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
986 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
987 c = 1024;
249
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
988 pred_dc = 1024;
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
989 if (s->ac_pred) {
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
990 if (s->h263_aic_dir) {
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
991 /* left prediction */
249
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
992 if (a != 1024) {
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
993 ac_val -= 16;
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
994 for(i=1;i<8;i++) {
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
995 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
996 }
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
997 pred_dc = a;
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
998 }
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
999 } else {
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1000 /* top prediction */
249
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1001 if (c != 1024) {
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1002 ac_val -= 16 * wrap;
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1003 for(i=1;i<8;i++) {
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
1004 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
1005 }
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1006 pred_dc = c;
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1007 }
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1008 }
249
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1009 } else {
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1010 /* just DC prediction */
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1011 if (a != 1024 && c != 1024)
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1012 pred_dc = (a + c) >> 1;
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1013 else if (a != 1024)
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1014 pred_dc = a;
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1015 else
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1016 pred_dc = c;
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1017 }
249
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1018
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1019 /* we assume pred is positive */
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1020 block[0]=block[0]*scale + pred_dc;
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1021
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1022 if (block[0] < 0)
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1023 block[0] = 0;
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1024 else if (!(block[0] & 1))
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1025 block[0]++;
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1026
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1027 /* Update AC/DC tables */
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1028 dc_val[(x) + (y) * wrap] = block[0];
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1029
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1030 /* left copy */
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1031 for(i=1;i<8;i++)
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
1032 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
1033 /* top copy */
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1034 for(i=1;i<8;i++)
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
1035 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
1036 }
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1037
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1038 INT16 *h263_pred_motion(MpegEncContext * s, int block,
986e461dc072 Initial revision
glantau
parents:
diff changeset
1039 int *px, int *py)
986e461dc072 Initial revision
glantau
parents:
diff changeset
1040 {
266
252444e5259b optimization
michaelni
parents: 265
diff changeset
1041 int xy, wrap;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1042 INT16 *A, *B, *C, *mot_val;
264
28c5c62b1c4c support decoding (with mplayer) of 3 .mp4 files from mphq
michaelni
parents: 263
diff changeset
1043 static const int off[4]= {2, 1, 1, -1};
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1044
266
252444e5259b optimization
michaelni
parents: 265
diff changeset
1045 wrap = s->block_wrap[0];
252444e5259b optimization
michaelni
parents: 265
diff changeset
1046 xy = s->block_index[block];
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1047
245
a023f78e0cc2 * simplified indexing
kabi
parents: 241
diff changeset
1048 mot_val = s->motion_val[xy];
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1049
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1050 A = s->motion_val[xy - 1];
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1051 /* special case for first (slice) line */
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
1052 if (s->first_slice_line && block<3) {
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1053 // 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
1054 // 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
1055 if(block==0){ //most common case
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1056 if(s->mb_x == s->resync_mb_x){ //rare
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1057 *px= *py = 0;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1058 }else if(s->mb_x + 1 == s->resync_mb_x){ //rare
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1059 C = s->motion_val[xy + off[block] - wrap];
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1060 if(s->mb_x==0){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1061 *px = C[0];
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1062 *py = C[1];
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1063 }else{
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1064 *px = mid_pred(A[0], 0, C[0]);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1065 *py = mid_pred(A[1], 0, C[1]);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1066 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1067 }else{
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1068 *px = A[0];
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1069 *py = A[1];
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1070 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1071 }else if(block==1){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1072 if(s->mb_x + 1 == s->resync_mb_x){ //rare
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1073 C = s->motion_val[xy + off[block] - wrap];
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1074 *px = mid_pred(A[0], 0, C[0]);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1075 *py = mid_pred(A[1], 0, C[1]);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1076 }else{
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1077 *px = A[0];
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1078 *py = A[1];
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1079 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1080 }else{ /* block==2*/
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1081 B = s->motion_val[xy - wrap];
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1082 C = s->motion_val[xy + off[block] - wrap];
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1083 if(s->mb_x == s->resync_mb_x) //rare
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1084 A[0]=A[1]=0;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1085
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1086 *px = mid_pred(A[0], B[0], C[0]);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1087 *py = mid_pred(A[1], B[1], C[1]);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1088 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1089 } else {
264
28c5c62b1c4c support decoding (with mplayer) of 3 .mp4 files from mphq
michaelni
parents: 263
diff changeset
1090 B = s->motion_val[xy - wrap];
28c5c62b1c4c support decoding (with mplayer) of 3 .mp4 files from mphq
michaelni
parents: 263
diff changeset
1091 C = s->motion_val[xy + off[block] - wrap];
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1092 *px = mid_pred(A[0], B[0], C[0]);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1093 *py = mid_pred(A[1], B[1], C[1]);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1094 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1095 return mot_val;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1096 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1097
815
78accc54493b put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents: 770
diff changeset
1098 #ifdef CONFIG_ENCODERS
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
1099 static void h263_encode_motion(MpegEncContext * s, int val, int f_code)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1100 {
702
2cff6fc37716 minor optimization of h263_encode_motion()
michaelni
parents: 701
diff changeset
1101 int range, l, bit_size, sign, code, bits;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1102
986e461dc072 Initial revision
glantau
parents:
diff changeset
1103 if (val == 0) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1104 /* zero vector */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1105 code = 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1106 put_bits(&s->pb, mvtab[code][1], mvtab[code][0]);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1107 } else {
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
1108 bit_size = f_code - 1;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1109 range = 1 << bit_size;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1110 /* modulo encoding */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1111 l = range * 32;
702
2cff6fc37716 minor optimization of h263_encode_motion()
michaelni
parents: 701
diff changeset
1112 #if 1
2cff6fc37716 minor optimization of h263_encode_motion()
michaelni
parents: 701
diff changeset
1113 val+= l;
2cff6fc37716 minor optimization of h263_encode_motion()
michaelni
parents: 701
diff changeset
1114 val&= 2*l-1;
2cff6fc37716 minor optimization of h263_encode_motion()
michaelni
parents: 701
diff changeset
1115 val-= l;
2cff6fc37716 minor optimization of h263_encode_motion()
michaelni
parents: 701
diff changeset
1116 sign = val>>31;
2cff6fc37716 minor optimization of h263_encode_motion()
michaelni
parents: 701
diff changeset
1117 val= (val^sign)-sign;
2cff6fc37716 minor optimization of h263_encode_motion()
michaelni
parents: 701
diff changeset
1118 sign&=1;
2cff6fc37716 minor optimization of h263_encode_motion()
michaelni
parents: 701
diff changeset
1119 #else
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1120 if (val < -l) {
702
2cff6fc37716 minor optimization of h263_encode_motion()
michaelni
parents: 701
diff changeset
1121 val += 2*l;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1122 } else if (val >= l) {
702
2cff6fc37716 minor optimization of h263_encode_motion()
michaelni
parents: 701
diff changeset
1123 val -= 2*l;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1124 }
702
2cff6fc37716 minor optimization of h263_encode_motion()
michaelni
parents: 701
diff changeset
1125
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
1126 assert(val>=-l && val<l);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1127
986e461dc072 Initial revision
glantau
parents:
diff changeset
1128 if (val >= 0) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1129 sign = 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1130 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1131 val = -val;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1132 sign = 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1133 }
702
2cff6fc37716 minor optimization of h263_encode_motion()
michaelni
parents: 701
diff changeset
1134 #endif
312
8cf5507e6ca5 mpeg4 mpeg quantizer support
michaelni
parents: 301
diff changeset
1135 val--;
8cf5507e6ca5 mpeg4 mpeg quantizer support
michaelni
parents: 301
diff changeset
1136 code = (val >> bit_size) + 1;
8cf5507e6ca5 mpeg4 mpeg quantizer support
michaelni
parents: 301
diff changeset
1137 bits = val & (range - 1);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1138
986e461dc072 Initial revision
glantau
parents:
diff changeset
1139 put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1140 if (bit_size > 0) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1141 put_bits(&s->pb, bit_size, bits);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1142 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1143 }
718
16dab8296293 fixing custom quantizer matrix decoding
michaelni
parents: 706
diff changeset
1144
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1145 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1146
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1147 /* Encode MV differences on H.263+ with Unrestricted MV mode */
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1148 static void h263p_encode_umotion(MpegEncContext * s, int val)
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1149 {
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1150 short sval = 0;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1151 short i = 0;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1152 short n_bits = 0;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1153 short temp_val;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1154 int code = 0;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1155 int tcode;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1156
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1157 if ( val == 0)
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1158 put_bits(&s->pb, 1, 1);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1159 else if (val == 1)
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1160 put_bits(&s->pb, 3, 0);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1161 else if (val == -1)
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1162 put_bits(&s->pb, 3, 2);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1163 else {
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1164
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1165 sval = ((val < 0) ? (short)(-val):(short)val);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1166 temp_val = sval;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1167
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1168 while (temp_val != 0) {
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1169 temp_val = temp_val >> 1;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1170 n_bits++;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1171 }
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1172
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1173 i = n_bits - 1;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1174 while (i > 0) {
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1175 tcode = (sval & (1 << (i-1))) >> (i-1);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1176 tcode = (tcode << 1) | 1;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1177 code = (code << 2) | tcode;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1178 i--;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1179 }
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1180 code = ((code << 1) | (val < 0)) << 1;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1181 put_bits(&s->pb, (2*n_bits)+1, code);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1182 //printf("\nVal = %d\tCode = %d", sval, code);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1183 }
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1184 }
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1185
277
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1186 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
1187 {
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1188 int f_code;
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1189 int mv;
815
78accc54493b put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents: 770
diff changeset
1190
78accc54493b put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents: 770
diff changeset
1191 if(mv_penalty==NULL)
78accc54493b put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents: 770
diff changeset
1192 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
1193
277
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1194 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
1195 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
1196 int len;
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1197
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1198 if(mv==0) len= mvtab[0][1];
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1199 else{
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1200 int val, bit_size, range, code;
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1201
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1202 bit_size = s->f_code - 1;
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1203 range = 1 << bit_size;
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1204
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1205 val=mv;
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1206 if (val < 0)
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1207 val = -val;
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1208 val--;
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1209 code = (val >> bit_size) + 1;
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1210 if(code<33){
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1211 len= mvtab[code][1] + 1 + bit_size;
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1212 }else{
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1213 len= mvtab[32][1] + 2 + bit_size;
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1214 }
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1215 }
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1216
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1217 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
1218 }
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1219 }
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1220
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1221 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
1222 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
1223 fcode_tab[mv+MAX_MV]= f_code;
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1224 }
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1225 }
287
32a3dcce2e9b fixing motion estimation with h263p hopefully
michaelni
parents: 286
diff changeset
1226
32a3dcce2e9b fixing motion estimation with h263p hopefully
michaelni
parents: 286
diff changeset
1227 for(mv=0; mv<MAX_MV*2+1; mv++){
32a3dcce2e9b fixing motion estimation with h263p hopefully
michaelni
parents: 286
diff changeset
1228 umv_fcode_tab[mv]= 1;
32a3dcce2e9b fixing motion estimation with h263p hopefully
michaelni
parents: 286
diff changeset
1229 }
277
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1230 }
815
78accc54493b put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents: 770
diff changeset
1231 #endif
277
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1232
468
1e23eae32087 Minor warning cleanup.
mellum
parents: 453
diff changeset
1233 static void init_uni_dc_tab(void)
293
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1234 {
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1235 int level, uni_code, uni_len;
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1236
312
8cf5507e6ca5 mpeg4 mpeg quantizer support
michaelni
parents: 301
diff changeset
1237 for(level=-256; level<256; level++){
293
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1238 int size, v, l;
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1239 /* find number of bits */
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1240 size = 0;
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1241 v = abs(level);
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1242 while (v) {
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1243 v >>= 1;
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1244 size++;
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1245 }
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1246
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1247 if (level < 0)
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1248 l= (-level) ^ ((1 << size) - 1);
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1249 else
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1250 l= level;
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1251
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1252 /* luminance */
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1253 uni_code= DCtab_lum[size][0];
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1254 uni_len = DCtab_lum[size][1];
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1255
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1256 if (size > 0) {
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1257 uni_code<<=size; uni_code|=l;
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1258 uni_len+=size;
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1259 if (size > 8){
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1260 uni_code<<=1; uni_code|=1;
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1261 uni_len++;
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1262 }
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1263 }
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1264 uni_DCtab_lum[level+256][0]= uni_code;
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1265 uni_DCtab_lum[level+256][1]= uni_len;
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1266
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1267 /* chrominance */
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1268 uni_code= DCtab_chrom[size][0];
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1269 uni_len = DCtab_chrom[size][1];
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1270
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1271 if (size > 0) {
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1272 uni_code<<=size; uni_code|=l;
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1273 uni_len+=size;
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1274 if (size > 8){
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1275 uni_code<<=1; uni_code|=1;
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1276 uni_len++;
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1277 }
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1278 }
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1279 uni_DCtab_chrom[level+256][0]= uni_code;
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1280 uni_DCtab_chrom[level+256][1]= uni_len;
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1281
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1282 }
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1283 }
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1284
815
78accc54493b put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents: 770
diff changeset
1285 #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
1286 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
1287 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
1288
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 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
1290 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
1291
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 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
1293 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
1294 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
1295 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
1296 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
1297 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
1298 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
1299 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
1300 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
1301
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 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
1303
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 /* 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
1305 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
1306 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
1307 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
1308 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
1309
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 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
1311 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
1312 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
1313 }
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 #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
1315 /* 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
1316 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
1317 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
1318 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
1319 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
1320 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
1321 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
1322 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
1323 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
1324 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
1325 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
1326
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 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
1328 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
1329 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
1330 }
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 }
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 #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
1333 #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
1334 /* 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
1335 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
1336 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
1337 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
1338 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
1339 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
1340 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
1341 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
1342 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
1343 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
1344 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
1345
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
1346 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
1347 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
1348 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
1349 }
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
1350 }
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
1351 #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
1352 /* 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
1353 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
1354 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
1355 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
1356 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
1357 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
1358 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
1359 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
1360 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
1361
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
1362 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
1363 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
1364 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
1365 }
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
1366 }
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
1367 }
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
1368 }
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
1369 }
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
1370
277
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1371 void h263_encode_init(MpegEncContext *s)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1372 {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1373 static int done = 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1374
986e461dc072 Initial revision
glantau
parents:
diff changeset
1375 if (!done) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1376 done = 1;
293
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1377
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1378 init_uni_dc_tab();
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1379
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1380 init_rl(&rl_inter);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1381 init_rl(&rl_intra);
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1382 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
1383
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
1384 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
1385 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
1386
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1387 init_mv_penalty_and_fcode(s);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1388 }
287
32a3dcce2e9b fixing motion estimation with h263p hopefully
michaelni
parents: 286
diff changeset
1389 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
1390
287
32a3dcce2e9b fixing motion estimation with h263p hopefully
michaelni
parents: 286
diff changeset
1391 // use fcodes >1 only for mpeg4 & h263 & h263p FIXME
344
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
1392 switch(s->codec_id){
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
1393 case CODEC_ID_MPEG4:
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
1394 s->fcode_tab= fcode_tab;
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
1395 s->min_qcoeff= -2048;
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
1396 s->max_qcoeff= 2047;
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
1397 break;
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
1398 case CODEC_ID_H263P:
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
1399 s->fcode_tab= umv_fcode_tab;
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
1400 s->min_qcoeff= -128;
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
1401 s->max_qcoeff= 127;
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
1402 break;
498
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
1403 //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
1404 default: //nothing needed default table allready set in mpegvideo.c
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
1405 s->min_qcoeff= -128;
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
1406 s->max_qcoeff= 127;
498
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
1407 s->y_dc_scale_table=
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
1408 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
344
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
1409 }
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
1410
599
b1a191202f96 mpeg4 mpeg quantizer encoding
michaelni
parents: 598
diff changeset
1411 if(s->mpeg_quant){
b1a191202f96 mpeg4 mpeg quantizer encoding
michaelni
parents: 598
diff changeset
1412 s->intra_quant_bias= 3<<(QUANT_BIAS_SHIFT-3); //(a + x*3/8)/x
b1a191202f96 mpeg4 mpeg quantizer encoding
michaelni
parents: 598
diff changeset
1413 s->inter_quant_bias= 0;
b1a191202f96 mpeg4 mpeg quantizer encoding
michaelni
parents: 598
diff changeset
1414 }else{
b1a191202f96 mpeg4 mpeg quantizer encoding
michaelni
parents: 598
diff changeset
1415 s->intra_quant_bias=0;
b1a191202f96 mpeg4 mpeg quantizer encoding
michaelni
parents: 598
diff changeset
1416 s->inter_quant_bias=-(1<<(QUANT_BIAS_SHIFT-2)); //(a - x/4)/x
b1a191202f96 mpeg4 mpeg quantizer encoding
michaelni
parents: 598
diff changeset
1417 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1418 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1419
986e461dc072 Initial revision
glantau
parents:
diff changeset
1420 static void h263_encode_block(MpegEncContext * s, DCTELEM * block, int n)
986e461dc072 Initial revision
glantau
parents:
diff changeset
1421 {
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1422 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
1423 RLTable *rl;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1424
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1425 rl = &rl_inter;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1426 if (s->mb_intra && !s->h263_aic) {
231
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
1427 /* DC coef */
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
1428 level = block[0];
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1429 /* 255 cannot be represented, so we clamp */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1430 if (level > 254) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1431 level = 254;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1432 block[0] = 254;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1433 }
231
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
1434 /* 0 cannot be represented also */
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
1435 else if (!level) {
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
1436 level = 1;
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
1437 block[0] = 1;
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
1438 }
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
1439 if (level == 128)
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
1440 put_bits(&s->pb, 8, 0xff);
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
1441 else
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
1442 put_bits(&s->pb, 8, level & 0xff);
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
1443 i = 1;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1444 } else {
231
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
1445 i = 0;
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1446 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
1447 rl = &rl_intra_aic;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1448 }
350
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 /* AC coefs */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1451 last_index = s->block_last_index[n];
986e461dc072 Initial revision
glantau
parents:
diff changeset
1452 last_non_zero = i - 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1453 for (; i <= last_index; i++) {
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
1454 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
1455 level = block[j];
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1456 if (level) {
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1457 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
1458 last = (i == last_index);
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1459 sign = 0;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1460 slevel = level;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1461 if (level < 0) {
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1462 sign = 1;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1463 level = -level;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1464 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1465 code = get_rl_index(rl, last, run, level);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1466 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1467 if (code == rl->n) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1468 put_bits(&s->pb, 1, last);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1469 put_bits(&s->pb, 6, run);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1470 put_bits(&s->pb, 8, slevel & 0xff);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1471 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1472 put_bits(&s->pb, 1, sign);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1473 }
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1474 last_non_zero = i;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1475 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1476 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1477 }
815
78accc54493b put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents: 770
diff changeset
1478 #endif
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1479
986e461dc072 Initial revision
glantau
parents:
diff changeset
1480 /***************************************************/
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
1481 /**
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
1482 * add mpeg4 stuffing bits (01...1)
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
1483 */
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1484 void ff_mpeg4_stuffing(PutBitContext * pbc)
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1485 {
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1486 int length;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1487 put_bits(pbc, 1, 0);
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1488 length= (-get_bit_count(pbc))&7;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1489 if(length) put_bits(pbc, length, (1<<length)-1);
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1490 }
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1491
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
1492 /* must be called before writing the header */
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
1493 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
1494 int time_div, time_mod;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
1495
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
1496 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
1497 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
1498 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
1499
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
1500 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
1501 }
654
850098147a3c export pts from stream if available
michaelni
parents: 648
diff changeset
1502
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
1503 if(s->current_picture.pts)
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
1504 s->time= (s->current_picture.pts*s->time_increment_resolution + 500*1000)/(1000*1000);
654
850098147a3c export pts from stream if available
michaelni
parents: 648
diff changeset
1505 else
850098147a3c export pts from stream if available
michaelni
parents: 648
diff changeset
1506 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
1507 time_div= s->time/s->time_increment_resolution;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
1508 time_mod= s->time%s->time_increment_resolution;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
1509
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
1510 if(s->pict_type==B_TYPE){
664
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
1511 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
1512 }else{
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
1513 s->last_time_base= s->time_base;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
1514 s->time_base= time_div;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
1515 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
1516 s->last_non_b_time= s->time;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
1517 }
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
1518 }
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
1519
263
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1520 static void mpeg4_encode_vol_header(MpegEncContext * s)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1521 {
263
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1522 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
1523 char buf[255];
336
c56b45669214 export delay info
michaelni
parents: 335
diff changeset
1524
923
3b5d9ecedc73 correct mpeg4 vo type
michaelni
parents: 921
diff changeset
1525 if(s->max_b_frames){
3b5d9ecedc73 correct mpeg4 vo type
michaelni
parents: 921
diff changeset
1526 s->vo_type= ADV_SIMPLE_VO_TYPE;
3b5d9ecedc73 correct mpeg4 vo type
michaelni
parents: 921
diff changeset
1527 }else{
3b5d9ecedc73 correct mpeg4 vo type
michaelni
parents: 921
diff changeset
1528 s->vo_type= SIMPLE_VO_TYPE;
3b5d9ecedc73 correct mpeg4 vo type
michaelni
parents: 921
diff changeset
1529 }
336
c56b45669214 export delay info
michaelni
parents: 335
diff changeset
1530
263
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1531 put_bits(&s->pb, 16, 0);
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1532 put_bits(&s->pb, 16, 0x100); /* video obj */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1533 put_bits(&s->pb, 16, 0);
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1534 put_bits(&s->pb, 16, 0x120); /* video obj layer */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1535
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1536 put_bits(&s->pb, 1, 0); /* random access vol */
336
c56b45669214 export delay info
michaelni
parents: 335
diff changeset
1537 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
1538 put_bits(&s->pb, 1, 1); /* is obj layer id= yes */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1539 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
1540 put_bits(&s->pb, 3, 1); /* is obj layer priority */
880
1c32039e7215 aspect ratio cleanup
michaelni
parents: 853
diff changeset
1541
887
19f5b8b7c6d5 fixing aspect
michaelni
parents: 880
diff changeset
1542 float_aspect_to_info(s, s->avctx->aspect_ratio);
880
1c32039e7215 aspect ratio cleanup
michaelni
parents: 853
diff changeset
1543
1c32039e7215 aspect ratio cleanup
michaelni
parents: 853
diff changeset
1544 put_bits(&s->pb, 4, s->aspect_ratio_info);/* 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
1545 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
1546 {
b4bddbde44f3 aspect (ext. par too) support for h263 and mpeg4 (inc. build becouse of new vars)
al3x
parents: 667
diff changeset
1547 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
1548 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
1549 }
336
c56b45669214 export delay info
michaelni
parents: 335
diff changeset
1550
c56b45669214 export delay info
michaelni
parents: 335
diff changeset
1551 if(s->low_delay){
c56b45669214 export delay info
michaelni
parents: 335
diff changeset
1552 put_bits(&s->pb, 1, 1); /* vol control parameters= yes */
341
bf26081c373c avcodec_flush_buffers()
michaelni
parents: 339
diff changeset
1553 put_bits(&s->pb, 2, 1); /* chroma format YUV 420/YV12 */
336
c56b45669214 export delay info
michaelni
parents: 335
diff changeset
1554 put_bits(&s->pb, 1, s->low_delay);
c56b45669214 export delay info
michaelni
parents: 335
diff changeset
1555 put_bits(&s->pb, 1, 0); /* vbv parameters= no */
c56b45669214 export delay info
michaelni
parents: 335
diff changeset
1556 }else{
c56b45669214 export delay info
michaelni
parents: 335
diff changeset
1557 put_bits(&s->pb, 1, 0); /* vol control parameters= no */
c56b45669214 export delay info
michaelni
parents: 335
diff changeset
1558 }
c56b45669214 export delay info
michaelni
parents: 335
diff changeset
1559
263
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1560 put_bits(&s->pb, 2, RECT_SHAPE); /* vol shape= rectangle */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1561 put_bits(&s->pb, 1, 1); /* marker bit */
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
1562
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
1563 put_bits(&s->pb, 16, s->time_increment_resolution);
263
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1564 if (s->time_increment_bits < 1)
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1565 s->time_increment_bits = 1;
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1566 put_bits(&s->pb, 1, 1); /* marker bit */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1567 put_bits(&s->pb, 1, 0); /* fixed vop rate=no */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1568 put_bits(&s->pb, 1, 1); /* marker bit */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1569 put_bits(&s->pb, 13, s->width); /* vol width */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1570 put_bits(&s->pb, 1, 1); /* marker bit */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1571 put_bits(&s->pb, 13, s->height); /* vol height */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1572 put_bits(&s->pb, 1, 1); /* marker bit */
697
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
1573 put_bits(&s->pb, 1, s->progressive_sequence ? 0 : 1);
263
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1574 put_bits(&s->pb, 1, 1); /* obmc disable */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1575 if (vo_ver_id == 1) {
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1576 put_bits(&s->pb, 1, s->vol_sprite_usage=0); /* sprite enable */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1577 }else{ /* vo_ver_id == 2 */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1578 put_bits(&s->pb, 2, s->vol_sprite_usage=0); /* sprite enable */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1579 }
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
1580
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
1581 s->quant_precision=5;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
1582 put_bits(&s->pb, 1, 0); /* not 8 bit == false */
599
b1a191202f96 mpeg4 mpeg quantizer encoding
michaelni
parents: 598
diff changeset
1583 put_bits(&s->pb, 1, s->mpeg_quant); /* quant type= (0=h263 style)*/
b1a191202f96 mpeg4 mpeg quantizer encoding
michaelni
parents: 598
diff changeset
1584 if(s->mpeg_quant) put_bits(&s->pb, 2, 0); /* no custom matrixes */
b1a191202f96 mpeg4 mpeg quantizer encoding
michaelni
parents: 598
diff changeset
1585
263
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1586 if (vo_ver_id != 1)
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1587 put_bits(&s->pb, 1, s->quarter_sample=0);
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1588 put_bits(&s->pb, 1, 1); /* complexity estimation disable */
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1589 s->resync_marker= s->rtp_mode;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1590 put_bits(&s->pb, 1, s->resync_marker ? 0 : 1);/* resync marker disable */
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1591 put_bits(&s->pb, 1, s->data_partitioning ? 1 : 0);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1592 if(s->data_partitioning){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1593 put_bits(&s->pb, 1, 0); /* no rvlc */
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1594 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1595
263
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1596 if (vo_ver_id != 1){
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1597 put_bits(&s->pb, 1, 0); /* newpred */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1598 put_bits(&s->pb, 1, 0); /* reduced res vop */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1599 }
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1600 put_bits(&s->pb, 1, 0); /* scalability */
676
c3bdb00a98a9 dont store version for bit-exact tests
michaelni
parents: 674
diff changeset
1601
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1602 ff_mpeg4_stuffing(&s->pb);
676
c3bdb00a98a9 dont store version for bit-exact tests
michaelni
parents: 674
diff changeset
1603
c3bdb00a98a9 dont store version for bit-exact tests
michaelni
parents: 674
diff changeset
1604 /* user data */
c3bdb00a98a9 dont store version for bit-exact tests
michaelni
parents: 674
diff changeset
1605 if(!ff_bit_exact){
c3bdb00a98a9 dont store version for bit-exact tests
michaelni
parents: 674
diff changeset
1606 put_bits(&s->pb, 16, 0);
c3bdb00a98a9 dont store version for bit-exact tests
michaelni
parents: 674
diff changeset
1607 put_bits(&s->pb, 16, 0x1B2); /* user_data */
c3bdb00a98a9 dont store version for bit-exact tests
michaelni
parents: 674
diff changeset
1608 sprintf(buf, "FFmpeg%sb%s", FFMPEG_VERSION, LIBAVCODEC_BUILD_STR);
c3bdb00a98a9 dont store version for bit-exact tests
michaelni
parents: 674
diff changeset
1609 put_string(&s->pb, buf);
c3bdb00a98a9 dont store version for bit-exact tests
michaelni
parents: 674
diff changeset
1610 ff_mpeg4_stuffing(&s->pb);
c3bdb00a98a9 dont store version for bit-exact tests
michaelni
parents: 674
diff changeset
1611 }
263
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1612 }
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1613
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1614 /* write mpeg4 VOP header */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1615 void mpeg4_encode_picture_header(MpegEncContext * s, int picture_number)
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1616 {
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
1617 int time_incr;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
1618 int time_div, time_mod;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
1619
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1620 if(s->pict_type==I_TYPE){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1621 s->no_rounding=0;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1622 if(picture_number==0 || !s->strict_std_compliance)
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1623 mpeg4_encode_vol_header(s);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1624 }
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
1625
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
1626 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
1627
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
1628 //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
1629
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
1630 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
1631 put_bits(&s->pb, 16, 0x1B6); /* vop header */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1632 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
1633
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
1634 time_div= s->time/s->time_increment_resolution;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
1635 time_mod= s->time%s->time_increment_resolution;
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
1636 time_incr= time_div - s->last_time_base;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
1637 while(time_incr--)
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
1638 put_bits(&s->pb, 1, 1);
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
1639
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1640 put_bits(&s->pb, 1, 0);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1641
986e461dc072 Initial revision
glantau
parents:
diff changeset
1642 put_bits(&s->pb, 1, 1); /* marker */
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
1643 put_bits(&s->pb, s->time_increment_bits, time_mod); /* time increment */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1644 put_bits(&s->pb, 1, 1); /* marker */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1645 put_bits(&s->pb, 1, 1); /* vop coded */
263
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1646 if ( s->pict_type == P_TYPE
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1647 || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE)) {
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1648 s->no_rounding ^= 1;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1649 put_bits(&s->pb, 1, s->no_rounding); /* rounding type */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1650 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1651 put_bits(&s->pb, 3, 0); /* intra dc VLC threshold */
697
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
1652 if(!s->progressive_sequence){
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
1653 put_bits(&s->pb, 1, s->top_field_first);
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
1654 put_bits(&s->pb, 1, s->alternate_scan);
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
1655 }
263
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1656 //FIXME sprite stuff
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1657
986e461dc072 Initial revision
glantau
parents:
diff changeset
1658 put_bits(&s->pb, 5, s->qscale);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1659
986e461dc072 Initial revision
glantau
parents:
diff changeset
1660 if (s->pict_type != I_TYPE)
986e461dc072 Initial revision
glantau
parents:
diff changeset
1661 put_bits(&s->pb, 3, s->f_code); /* fcode_for */
263
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1662 if (s->pict_type == B_TYPE)
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1663 put_bits(&s->pb, 3, s->b_code); /* fcode_back */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1664 // printf("****frame %d\n", picture_number);
498
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
1665
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
1666 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
1667 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
1668 s->h_edge_pos= s->width;
5132a4ee50cd different edge positions fixed with edge emu / dr1
michaelni
parents: 575
diff changeset
1669 s->v_edge_pos= s->height;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1670 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1671
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
1672 /**
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
1673 * 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
1674 */
698
e050a053e259 h263_dc_scale() cleanup
michaelni
parents: 697
diff changeset
1675 static void change_qscale(MpegEncContext * s, int dquant)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1676 {
698
e050a053e259 h263_dc_scale() cleanup
michaelni
parents: 697
diff changeset
1677 s->qscale += dquant;
e050a053e259 h263_dc_scale() cleanup
michaelni
parents: 697
diff changeset
1678
e050a053e259 h263_dc_scale() cleanup
michaelni
parents: 697
diff changeset
1679 if (s->qscale < 1)
e050a053e259 h263_dc_scale() cleanup
michaelni
parents: 697
diff changeset
1680 s->qscale = 1;
e050a053e259 h263_dc_scale() cleanup
michaelni
parents: 697
diff changeset
1681 else if (s->qscale > 31)
e050a053e259 h263_dc_scale() cleanup
michaelni
parents: 697
diff changeset
1682 s->qscale = 31;
e050a053e259 h263_dc_scale() cleanup
michaelni
parents: 697
diff changeset
1683
498
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
1684 s->y_dc_scale= s->y_dc_scale_table[ s->qscale ];
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
1685 s->c_dc_scale= s->c_dc_scale_table[ s->qscale ];
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1686 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1687
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
1688 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
1689 {
266
252444e5259b optimization
michaelni
parents: 265
diff changeset
1690 int a, b, c, wrap, pred, scale;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1691 UINT16 *dc_val;
469
a5dd4eae1f0c Revert previous bogus warning fix.
mellum
parents: 468
diff changeset
1692 int dummy;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1693
986e461dc072 Initial revision
glantau
parents:
diff changeset
1694 /* find prediction */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1695 if (n < 4) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1696 scale = s->y_dc_scale;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1697 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1698 scale = s->c_dc_scale;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1699 }
266
252444e5259b optimization
michaelni
parents: 265
diff changeset
1700 wrap= s->block_wrap[n];
252444e5259b optimization
michaelni
parents: 265
diff changeset
1701 dc_val = s->dc_val[0] + s->block_index[n];
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1702
986e461dc072 Initial revision
glantau
parents:
diff changeset
1703 /* B C
986e461dc072 Initial revision
glantau
parents:
diff changeset
1704 * A X
986e461dc072 Initial revision
glantau
parents:
diff changeset
1705 */
266
252444e5259b optimization
michaelni
parents: 265
diff changeset
1706 a = dc_val[ - 1];
252444e5259b optimization
michaelni
parents: 265
diff changeset
1707 b = dc_val[ - 1 - wrap];
252444e5259b optimization
michaelni
parents: 265
diff changeset
1708 c = dc_val[ - wrap];
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1709
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
1710 /* 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
1711 if(s->first_slice_line && n!=3){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
1712 if(n!=2) b=c= 1024;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
1713 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
1714 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
1715 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
1716 if(n==0 || n==4 || n==5)
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
1717 b=1024;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
1718 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
1719
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1720 if (abs(a - b) < abs(b - c)) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1721 pred = c;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1722 *dir_ptr = 1; /* top */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1723 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1724 pred = a;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1725 *dir_ptr = 0; /* left */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1726 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1727 /* we assume pred is positive */
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1728 #ifdef ARCH_X86
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1729 asm volatile (
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1730 "xorl %%edx, %%edx \n\t"
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1731 "mul %%ecx \n\t"
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1732 : "=d" (pred), "=a"(dummy)
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1733 : "a" (pred + (scale >> 1)), "c" (inverse[scale])
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1734 );
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1735 #else
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1736 pred = (pred + (scale >> 1)) / scale;
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1737 #endif
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1738
986e461dc072 Initial revision
glantau
parents:
diff changeset
1739 /* prepare address for prediction update */
266
252444e5259b optimization
michaelni
parents: 265
diff changeset
1740 *dc_val_ptr = &dc_val[0];
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1741
986e461dc072 Initial revision
glantau
parents:
diff changeset
1742 return pred;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1743 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1744
174
ac5075a55488 new IDCT code by Michael Niedermayer (michaelni@gmx.at) - #define SIMPLE_IDCT to enable
arpi_esp
parents: 162
diff changeset
1745 void mpeg4_pred_ac(MpegEncContext * s, INT16 *block, int n,
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1746 int dir)
986e461dc072 Initial revision
glantau
parents:
diff changeset
1747 {
266
252444e5259b optimization
michaelni
parents: 265
diff changeset
1748 int i;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1749 INT16 *ac_val, *ac_val1;
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
1750 int8_t * const qscale_table= s->current_picture.qscale_table;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1751
986e461dc072 Initial revision
glantau
parents:
diff changeset
1752 /* find prediction */
266
252444e5259b optimization
michaelni
parents: 265
diff changeset
1753 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1754 ac_val1 = ac_val;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1755 if (s->ac_pred) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1756 if (dir == 0) {
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
1757 const int xy= s->mb_x-1 + s->mb_y*s->mb_width;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1758 /* left prediction */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1759 ac_val -= 16;
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
1760
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
1761 if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
1762 /* same qscale */
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
1763 for(i=1;i<8;i++) {
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
1764 block[s->idct_permutation[i<<3]] += ac_val[i];
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
1765 }
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
1766 }else{
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
1767 /* different qscale, we must rescale */
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
1768 for(i=1;i<8;i++) {
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
1769 block[s->idct_permutation[i<<3]] += ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale);
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
1770 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1771 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1772 } else {
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
1773 const int xy= s->mb_x + s->mb_y*s->mb_width - s->mb_width;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1774 /* top prediction */
266
252444e5259b optimization
michaelni
parents: 265
diff changeset
1775 ac_val -= 16 * s->block_wrap[n];
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
1776
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
1777 if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
1778 /* same qscale */
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
1779 for(i=1;i<8;i++) {
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
1780 block[s->idct_permutation[i]] += ac_val[i + 8];
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
1781 }
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
1782 }else{
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
1783 /* different qscale, we must rescale */
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
1784 for(i=1;i<8;i++) {
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
1785 block[s->idct_permutation[i]] += ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale);
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
1786 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1787 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1788 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1789 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1790 /* left copy */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1791 for(i=1;i<8;i++)
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
1792 ac_val1[i ] = block[s->idct_permutation[i<<3]];
591
d3f374218030 fixing mpeg4 mpeg quantizers
michaelni
parents: 582
diff changeset
1793
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1794 /* top copy */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1795 for(i=1;i<8;i++)
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
1796 ac_val1[8 + i] = block[s->idct_permutation[i ]];
591
d3f374218030 fixing mpeg4 mpeg quantizers
michaelni
parents: 582
diff changeset
1797
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1798 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1799
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1800 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
1801 int dir)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1802 {
266
252444e5259b optimization
michaelni
parents: 265
diff changeset
1803 int i;
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1804 INT16 *ac_val;
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
1805 int8_t * const qscale_table= s->current_picture.qscale_table;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1806
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1807 /* find prediction */
266
252444e5259b optimization
michaelni
parents: 265
diff changeset
1808 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
1809
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1810 if (dir == 0) {
692
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
1811 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
1812 /* left prediction */
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1813 ac_val -= 16;
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
1814 if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){
692
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
1815 /* same qscale */
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
1816 for(i=1;i<8;i++) {
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
1817 block[s->idct_permutation[i<<3]] -= ac_val[i];
692
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
1818 }
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
1819 }else{
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
1820 /* different qscale, we must rescale */
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
1821 for(i=1;i<8;i++) {
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
1822 block[s->idct_permutation[i<<3]] -= ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale);
692
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
1823 }
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1824 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1825 } else {
692
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
1826 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
1827 /* top prediction */
266
252444e5259b optimization
michaelni
parents: 265
diff changeset
1828 ac_val -= 16 * s->block_wrap[n];
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
1829 if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){
692
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
1830 /* same qscale */
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
1831 for(i=1;i<8;i++) {
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
1832 block[s->idct_permutation[i]] -= ac_val[i + 8];
692
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
1833 }
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
1834 }else{
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
1835 /* different qscale, we must rescale */
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
1836 for(i=1;i<8;i++) {
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
1837 block[s->idct_permutation[i]] -= ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale);
692
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
1838 }
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1839 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1840 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1841 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1842
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1843 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
1844 {
293
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1845 #if 1
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1846 // if(level<-255 || level>255) printf("dc overflow\n");
293
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1847 level+=256;
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1848 if (n < 4) {
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1849 /* luminance */
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1850 put_bits(s, uni_DCtab_lum[level][1], uni_DCtab_lum[level][0]);
293
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1851 } else {
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1852 /* chrominance */
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1853 put_bits(s, uni_DCtab_chrom[level][1], uni_DCtab_chrom[level][0]);
293
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1854 }
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1855 #else
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1856 int size, v;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1857 /* find number of bits */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1858 size = 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1859 v = abs(level);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1860 while (v) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1861 v >>= 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1862 size++;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1863 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1864
986e461dc072 Initial revision
glantau
parents:
diff changeset
1865 if (n < 4) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1866 /* luminance */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1867 put_bits(&s->pb, DCtab_lum[size][1], DCtab_lum[size][0]);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1868 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1869 /* chrominance */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1870 put_bits(&s->pb, DCtab_chrom[size][1], DCtab_chrom[size][0]);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1871 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1872
986e461dc072 Initial revision
glantau
parents:
diff changeset
1873 /* encode remaining bits */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1874 if (size > 0) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1875 if (level < 0)
986e461dc072 Initial revision
glantau
parents:
diff changeset
1876 level = (-level) ^ ((1 << size) - 1);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1877 put_bits(&s->pb, size, level);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1878 if (size > 8)
986e461dc072 Initial revision
glantau
parents:
diff changeset
1879 put_bits(&s->pb, 1, 1);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1880 }
293
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1881 #endif
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1882 }
815
78accc54493b put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents: 770
diff changeset
1883 #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
1884 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
1885 UINT8 *scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1886 {
751
cbe316f082bc warning fixes
michaelni
parents: 747
diff changeset
1887 int i, last_non_zero;
cbe316f082bc warning fixes
michaelni
parents: 747
diff changeset
1888 #if 0 //variables for the outcommented version
cbe316f082bc warning fixes
michaelni
parents: 747
diff changeset
1889 int code, sign, last;
cbe316f082bc warning fixes
michaelni
parents: 747
diff changeset
1890 #endif
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1891 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
1892 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
1893 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
1894 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
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 if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1897 /* mpeg4 based DC predictor */
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1898 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
1899 if(last_index<1) return;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1900 i = 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1901 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
1902 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
1903 len_tab = uni_mpeg4_intra_rl_len;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1904 } 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
1905 if(last_index<0) return;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1906 i = 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1907 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
1908 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
1909 len_tab = uni_mpeg4_inter_rl_len;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1910 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1911
986e461dc072 Initial revision
glantau
parents:
diff changeset
1912 /* AC coefs */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1913 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
1914 #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
1915 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
1916 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
1917 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
1918 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
1919 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
1920 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
1921 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
1922 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
1923 }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
1924 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
1925 }
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
1926 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
1927 }
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
1928 }
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
1929 /*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
1930 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
1931 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
1932 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
1933 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
1934 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
1935 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
1936 }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
1937 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
1938 }
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
1939 }
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
1940 #else
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1941 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
1942 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
1943 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
1944 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
1945 int run = i - last_non_zero - 1;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1946 last = (i == last_index);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1947 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
1948 level = slevel;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1949 if (level < 0) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1950 sign = 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1951 level = -level;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1952 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1953 code = get_rl_index(rl, last, run, level);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1954 put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1955 if (code == rl->n) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1956 int level1, run1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1957 level1 = level - rl->max_level[last][run];
986e461dc072 Initial revision
glantau
parents:
diff changeset
1958 if (level1 < 1)
986e461dc072 Initial revision
glantau
parents:
diff changeset
1959 goto esc2;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1960 code = get_rl_index(rl, last, run, level1);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1961 if (code == rl->n) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1962 esc2:
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1963 put_bits(ac_pb, 1, 1);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1964 if (level > MAX_LEVEL)
986e461dc072 Initial revision
glantau
parents:
diff changeset
1965 goto esc3;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1966 run1 = run - rl->max_run[last][level] - 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1967 if (run1 < 0)
986e461dc072 Initial revision
glantau
parents:
diff changeset
1968 goto esc3;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1969 code = get_rl_index(rl, last, run1, level);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1970 if (code == rl->n) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1971 esc3:
986e461dc072 Initial revision
glantau
parents:
diff changeset
1972 /* third escape */
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1973 put_bits(ac_pb, 1, 1);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1974 put_bits(ac_pb, 1, last);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1975 put_bits(ac_pb, 6, run);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1976 put_bits(ac_pb, 1, 1);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1977 put_bits(ac_pb, 12, slevel & 0xfff);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1978 put_bits(ac_pb, 1, 1);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1979 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1980 /* second escape */
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1981 put_bits(ac_pb, 1, 0);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1982 put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1983 put_bits(ac_pb, 1, sign);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1984 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1985 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1986 /* first escape */
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1987 put_bits(ac_pb, 1, 0);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1988 put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1989 put_bits(ac_pb, 1, sign);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1990 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1991 } else {
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1992 put_bits(ac_pb, 1, sign);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1993 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1994 last_non_zero = i;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1995 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1996 }
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
1997 #endif
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1998 }
815
78accc54493b put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents: 770
diff changeset
1999 #endif
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2000
986e461dc072 Initial revision
glantau
parents:
diff changeset
2001
986e461dc072 Initial revision
glantau
parents:
diff changeset
2002 /***********************************************/
986e461dc072 Initial revision
glantau
parents:
diff changeset
2003 /* decoding */
986e461dc072 Initial revision
glantau
parents:
diff changeset
2004
986e461dc072 Initial revision
glantau
parents:
diff changeset
2005 static VLC intra_MCBPC_vlc;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2006 static VLC inter_MCBPC_vlc;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2007 static VLC cbpy_vlc;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2008 static VLC mv_vlc;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2009 static VLC dc_lum, dc_chrom;
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
2010 static VLC sprite_trajectory;
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2011 static VLC mb_type_b_vlc;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2012
986e461dc072 Initial revision
glantau
parents:
diff changeset
2013 void init_rl(RLTable *rl)
986e461dc072 Initial revision
glantau
parents:
diff changeset
2014 {
986e461dc072 Initial revision
glantau
parents:
diff changeset
2015 INT8 max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
986e461dc072 Initial revision
glantau
parents:
diff changeset
2016 UINT8 index_run[MAX_RUN+1];
986e461dc072 Initial revision
glantau
parents:
diff changeset
2017 int last, run, level, start, end, i;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2018
986e461dc072 Initial revision
glantau
parents:
diff changeset
2019 /* compute max_level[], max_run[] and index_run[] */
986e461dc072 Initial revision
glantau
parents:
diff changeset
2020 for(last=0;last<2;last++) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
2021 if (last == 0) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
2022 start = 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2023 end = rl->last;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2024 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
2025 start = rl->last;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2026 end = rl->n;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2027 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
2028
986e461dc072 Initial revision
glantau
parents:
diff changeset
2029 memset(max_level, 0, MAX_RUN + 1);
986e461dc072 Initial revision
glantau
parents:
diff changeset
2030 memset(max_run, 0, MAX_LEVEL + 1);
986e461dc072 Initial revision
glantau
parents:
diff changeset
2031 memset(index_run, rl->n, MAX_RUN + 1);
986e461dc072 Initial revision
glantau
parents:
diff changeset
2032 for(i=start;i<end;i++) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
2033 run = rl->table_run[i];
986e461dc072 Initial revision
glantau
parents:
diff changeset
2034 level = rl->table_level[i];
986e461dc072 Initial revision
glantau
parents:
diff changeset
2035 if (index_run[run] == rl->n)
986e461dc072 Initial revision
glantau
parents:
diff changeset
2036 index_run[run] = i;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2037 if (level > max_level[run])
986e461dc072 Initial revision
glantau
parents:
diff changeset
2038 max_level[run] = level;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2039 if (run > max_run[level])
986e461dc072 Initial revision
glantau
parents:
diff changeset
2040 max_run[level] = run;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2041 }
396
fce0a2520551 removed useless header includes - use av memory functions
glantau
parents: 365
diff changeset
2042 rl->max_level[last] = av_malloc(MAX_RUN + 1);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2043 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
2044 rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2045 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
2046 rl->index_run[last] = av_malloc(MAX_RUN + 1);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2047 memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
986e461dc072 Initial revision
glantau
parents:
diff changeset
2048 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
2049 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
2050
986e461dc072 Initial revision
glantau
parents:
diff changeset
2051 void init_vlc_rl(RLTable *rl)
986e461dc072 Initial revision
glantau
parents:
diff changeset
2052 {
542
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2053 int i, q;
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2054
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2055 init_vlc(&rl->vlc, 9, rl->n + 1,
986e461dc072 Initial revision
glantau
parents:
diff changeset
2056 &rl->table_vlc[0][1], 4, 2,
986e461dc072 Initial revision
glantau
parents:
diff changeset
2057 &rl->table_vlc[0][0], 4, 2);
542
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2058
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2059
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2060 for(q=0; q<32; q++){
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2061 int qmul= q*2;
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2062 int qadd= (q-1)|1;
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2063
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2064 if(q==0){
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2065 qmul=1;
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2066 qadd=0;
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2067 }
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2068
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2069 rl->rl_vlc[q]= av_malloc(rl->vlc.table_size*sizeof(RL_VLC_ELEM));
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2070 for(i=0; i<rl->vlc.table_size; i++){
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2071 int code= rl->vlc.table[i][0];
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2072 int len = rl->vlc.table[i][1];
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2073 int level, run;
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2074
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2075 if(len==0){ // illegal code
563
61442627f857 fixes fire.avi & subtitles.avi
michaelni
parents: 549
diff changeset
2076 run= 66;
542
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2077 level= MAX_LEVEL;
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2078 }else if(len<0){ //more bits needed
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2079 run= 0;
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2080 level= code;
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2081 }else{
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2082 if(code==rl->n){ //esc
563
61442627f857 fixes fire.avi & subtitles.avi
michaelni
parents: 549
diff changeset
2083 run= 66;
542
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2084 level= 0;
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2085 }else{
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2086 run= rl->table_run [code] + 1;
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2087 level= rl->table_level[code] * qmul + qadd;
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2088 if(code >= rl->last) run+=192;
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2089 }
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2090 }
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2091 rl->rl_vlc[q][i].len= len;
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2092 rl->rl_vlc[q][i].level= level;
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2093 rl->rl_vlc[q][i].run= run;
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2094 }
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2095 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2096 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
2097
986e461dc072 Initial revision
glantau
parents:
diff changeset
2098 /* init vlcs */
986e461dc072 Initial revision
glantau
parents:
diff changeset
2099
986e461dc072 Initial revision
glantau
parents:
diff changeset
2100 /* XXX: find a better solution to handle static init */
986e461dc072 Initial revision
glantau
parents:
diff changeset
2101 void h263_decode_init_vlc(MpegEncContext *s)
986e461dc072 Initial revision
glantau
parents:
diff changeset
2102 {
986e461dc072 Initial revision
glantau
parents:
diff changeset
2103 static int done = 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2104
986e461dc072 Initial revision
glantau
parents:
diff changeset
2105 if (!done) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
2106 done = 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2107
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
2108 init_vlc(&intra_MCBPC_vlc, INTRA_MCBPC_VLC_BITS, 8,
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2109 intra_MCBPC_bits, 1, 1,
986e461dc072 Initial revision
glantau
parents:
diff changeset
2110 intra_MCBPC_code, 1, 1);
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
2111 init_vlc(&inter_MCBPC_vlc, INTER_MCBPC_VLC_BITS, 25,
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2112 inter_MCBPC_bits, 1, 1,
986e461dc072 Initial revision
glantau
parents:
diff changeset
2113 inter_MCBPC_code, 1, 1);
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
2114 init_vlc(&cbpy_vlc, CBPY_VLC_BITS, 16,
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2115 &cbpy_tab[0][1], 2, 1,
986e461dc072 Initial revision
glantau
parents:
diff changeset
2116 &cbpy_tab[0][0], 2, 1);
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
2117 init_vlc(&mv_vlc, MV_VLC_BITS, 33,
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2118 &mvtab[0][1], 2, 1,
986e461dc072 Initial revision
glantau
parents:
diff changeset
2119 &mvtab[0][0], 2, 1);
986e461dc072 Initial revision
glantau
parents:
diff changeset
2120 init_rl(&rl_inter);
986e461dc072 Initial revision
glantau
parents:
diff changeset
2121 init_rl(&rl_intra);
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
2122 init_rl(&rl_intra_aic);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2123 init_vlc_rl(&rl_inter);
986e461dc072 Initial revision
glantau
parents:
diff changeset
2124 init_vlc_rl(&rl_intra);
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
2125 init_vlc_rl(&rl_intra_aic);
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
2126 init_vlc(&dc_lum, DC_VLC_BITS, 10 /* 13 */,
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2127 &DCtab_lum[0][1], 2, 1,
986e461dc072 Initial revision
glantau
parents:
diff changeset
2128 &DCtab_lum[0][0], 2, 1);
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
2129 init_vlc(&dc_chrom, DC_VLC_BITS, 10 /* 13 */,
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2130 &DCtab_chrom[0][1], 2, 1,
986e461dc072 Initial revision
glantau
parents:
diff changeset
2131 &DCtab_chrom[0][0], 2, 1);
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
2132 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
2133 &sprite_trajectory_tab[0][1], 4, 2,
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
2134 &sprite_trajectory_tab[0][0], 4, 2);
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
2135 init_vlc(&mb_type_b_vlc, MB_TYPE_B_VLC_BITS, 4,
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2136 &mb_type_b_tab[0][1], 2, 1,
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2137 &mb_type_b_tab[0][0], 2, 1);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2138 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
2139 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
2140
745
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 * 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
2143 */
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2144 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
2145 if (s->height <= 400)
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2146 return 1;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2147 else if (s->height <= 800)
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2148 return 2;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2149 else
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2150 return 4;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2151 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2152
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2153 /**
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2154 * decodes the group of blocks header.
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2155 * @return <0 if an error occured
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2156 */
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2157 static int h263_decode_gob_header(MpegEncContext *s)
162
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
2158 {
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
2159 unsigned int val, gfid;
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2160 int left;
162
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
2161
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
2162 /* Check for GOB Start Code */
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
2163 val = show_bits(&s->gb, 16);
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2164 if(val)
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2165 return -1;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2166
162
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
2167 /* 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
2168 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
2169 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
2170 //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
2171 for(;left>13; left--){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2172 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
2173 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2174 if(left<=13)
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2175 return -1;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2176
162
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
2177 #ifdef DEBUG
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2178 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
2179 #endif
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2180 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
2181 gfid = get_bits(&s->gb, 2); /* GFID */
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2182 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
2183 if(s->qscale==0)
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2184 return -1;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2185 s->mb_x= 0;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2186 s->mb_y= s->gob_index* s->gob_number;
162
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
2187 #ifdef DEBUG
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2188 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
2189 #endif
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
2190 return 0;
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
2191 }
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
2192
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2193 static inline void memsetw(short *tab, int val, int n)
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2194 {
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2195 int i;
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2196 for(i=0;i<n;i++)
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2197 tab[i] = val;
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2198 }
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2199
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2200 void ff_mpeg4_init_partitions(MpegEncContext *s)
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2201 {
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2202 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
2203 init_put_bits(&s->pb2 , s->pb2_buffer , PB_BUFFER_SIZE, NULL, NULL);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2204 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2205
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2206 void ff_mpeg4_merge_partitions(MpegEncContext *s)
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2207 {
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2208 const int pb2_len = get_bit_count(&s->pb2 );
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2209 const int tex_pb_len= get_bit_count(&s->tex_pb);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2210 const int bits= get_bit_count(&s->pb);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2211
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2212 if(s->pict_type==I_TYPE){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2213 put_bits(&s->pb, 19, DC_MARKER);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2214 s->misc_bits+=19 + pb2_len + bits - s->last_bits;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2215 s->i_tex_bits+= tex_pb_len;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2216 }else{
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2217 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
2218 s->misc_bits+=17 + pb2_len;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2219 s->mv_bits+= bits - s->last_bits;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2220 s->p_tex_bits+= tex_pb_len;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2221 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2222
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2223 flush_put_bits(&s->pb2);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2224 flush_put_bits(&s->tex_pb);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2225
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2226 ff_copy_bits(&s->pb, s->pb2_buffer , pb2_len);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2227 ff_copy_bits(&s->pb, s->tex_pb_buffer, tex_pb_len);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2228 s->last_bits= get_bit_count(&s->pb);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2229 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2230
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2231 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
2232 switch(s->pict_type){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2233 case I_TYPE:
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2234 return 16;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2235 case P_TYPE:
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2236 case S_TYPE:
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2237 return s->f_code+15;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2238 case B_TYPE:
847
f3c369b8ddca reversing header game
michaelni
parents: 821
diff changeset
2239 return FFMAX(FFMAX(s->f_code, s->b_code)+15, 17);
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2240 default:
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2241 return -1;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2242 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2243 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2244
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2245 void ff_mpeg4_encode_video_packet_header(MpegEncContext *s)
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2246 {
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2247 int mb_num_bits= av_log2(s->mb_num - 1) + 1;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2248
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2249 ff_mpeg4_stuffing(&s->pb);
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2250 put_bits(&s->pb, ff_mpeg4_get_video_packet_prefix_length(s), 0);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2251 put_bits(&s->pb, 1, 1);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2252
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2253 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
2254 put_bits(&s->pb, s->quant_precision, s->qscale);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2255 put_bits(&s->pb, 1, 0); /* no HEC */
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2256 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2257
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2258 /**
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2259 * 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
2260 * @return 0 if not
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2261 */
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2262 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
2263 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
2264
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2265 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
2266 return 0;
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
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2269 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
2270 int v= show_bits(&s->gb, 8);
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2271 v|= 0x7F >> (7-(bits_count&7));
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2272
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2273 if(v==0x7F)
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2274 return 1;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2275 }else{
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2276 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
2277 int len;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2278 GetBitContext gb= s->gb;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2279
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2280 skip_bits(&s->gb, 1);
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2281 align_get_bits(&s->gb);
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2282
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2283 for(len=0; len<32; len++){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2284 if(get_bits1(&s->gb)) break;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2285 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2286
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2287 s->gb= gb;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2288
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2289 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
2290 return 1;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2291 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2292 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2293 return 0;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2294 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2295
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2296 /**
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2297 * decodes the next video packet.
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2298 * @return <0 if something went wrong
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2299 */
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2300 static int mpeg4_decode_video_packet_header(MpegEncContext *s)
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2301 {
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2302 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
2303 int header_extension=0, mb_num, len;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2304
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2305 /* 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
2306 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
2307
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2308 for(len=0; len<32; len++){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2309 if(get_bits1(&s->gb)) break;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2310 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2311
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2312 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
2313 printf("marker does not match f_code\n");
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2314 return -1;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2315 }
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2316
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2317 if(s->shape != RECT_SHAPE){
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2318 header_extension= get_bits1(&s->gb);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2319 //FIXME more stuff here
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2320 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2321
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2322 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
2323 if(mb_num>=s->mb_num){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2324 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
2325 return -1;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2326 }
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2327 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
2328 s->mb_y= mb_num / s->mb_width;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2329
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2330 if(s->shape != BIN_ONLY_SHAPE){
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2331 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
2332 if(qscale)
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2333 s->qscale= qscale;
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2334 }
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 if(s->shape == RECT_SHAPE){
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2337 header_extension= get_bits1(&s->gb);
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2338 }
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2339 if(header_extension){
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2340 int time_increment;
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2341 int time_incr=0;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2342
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2343 while (get_bits1(&s->gb) != 0)
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2344 time_incr++;
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2345
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2346 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
2347 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
2348 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
2349
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2350 skip_bits(&s->gb, 2); /* vop coding type */
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2351 //FIXME not rect stuff here
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2352
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2353 if(s->shape != BIN_ONLY_SHAPE){
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2354 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
2355 //FIXME dont just ignore everything
821
f5f2e162331c hopefully fixing sprite_warping_points==0
michaelni
parents: 815
diff changeset
2356 if(s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2357 mpeg4_decode_sprite_trajectory(s);
660
b8e268337a1d parsing resync header extension support
michaelni
parents: 659
diff changeset
2358 fprintf(stderr, "untested\n");
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2359 }
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2360
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2361 //FIXME reduced res stuff here
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2362
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2363 if (s->pict_type != I_TYPE) {
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2364 int f_code = get_bits(&s->gb, 3); /* fcode_for */
660
b8e268337a1d parsing resync header extension support
michaelni
parents: 659
diff changeset
2365 if(f_code==0){
b8e268337a1d parsing resync header extension support
michaelni
parents: 659
diff changeset
2366 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
2367 }
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2368 }
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2369 if (s->pict_type == B_TYPE) {
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2370 int b_code = get_bits(&s->gb, 3);
660
b8e268337a1d parsing resync header extension support
michaelni
parents: 659
diff changeset
2371 if(b_code==0){
b8e268337a1d parsing resync header extension support
michaelni
parents: 659
diff changeset
2372 printf("Error, video packet header damaged (b_code=0)\n");
b8e268337a1d parsing resync header extension support
michaelni
parents: 659
diff changeset
2373 }
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2374 }
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2375 }
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2376 }
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2377 //FIXME new-pred stuff
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2378
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2379 //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
2380
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2381 return 0;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2382 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2383
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2384 void ff_mpeg4_clean_buffers(MpegEncContext *s)
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2385 {
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2386 int c_wrap, c_xy, l_wrap, l_xy;
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2387
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2388 l_wrap= s->block_wrap[0];
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2389 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
2390 c_wrap= s->block_wrap[4];
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2391 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
2392
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2393 #if 0
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2394 /* clean DC */
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2395 memsetw(s->dc_val[0] + l_xy, 1024, l_wrap*2+1);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2396 memsetw(s->dc_val[1] + c_xy, 1024, c_wrap+1);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2397 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
2398 #endif
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2399
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2400 /* clean AC */
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2401 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
2402 memset(s->ac_val[1] + c_xy, 0, (c_wrap +1)*16*sizeof(INT16));
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2403 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
2404
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2405 /* clean MV */
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2406 // we cant clear the MVs as they might be needed by a b frame
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2407 // 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
2408 // 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
2409 s->last_mv[0][0][0]=
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2410 s->last_mv[0][0][1]=
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2411 s->last_mv[1][0][0]=
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2412 s->last_mv[1][0][1]= 0;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2413 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2414
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2415 /**
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2416 * 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
2417 * @return <0 if no resync found
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 int ff_h263_resync(MpegEncContext *s){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2420 int left, ret;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2421
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2422 if(s->codec_id==CODEC_ID_MPEG4)
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2423 skip_bits1(&s->gb);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2424
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2425 align_get_bits(&s->gb);
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2426
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2427 if(show_bits(&s->gb, 16)==0){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2428 if(s->codec_id==CODEC_ID_MPEG4)
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2429 ret= mpeg4_decode_video_packet_header(s);
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2430 else
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2431 ret= h263_decode_gob_header(s);
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2432 if(ret>=0)
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2433 return 0;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2434 }
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2435 //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
2436 s->gb= s->last_resync_gb;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2437 align_get_bits(&s->gb);
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2438 left= s->gb.size*8 - get_bits_count(&s->gb);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2439
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2440 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
2441 if(show_bits(&s->gb, 16)==0){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2442 GetBitContext bak= s->gb;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2443
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2444 if(s->codec_id==CODEC_ID_MPEG4)
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2445 ret= mpeg4_decode_video_packet_header(s);
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2446 else
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2447 ret= h263_decode_gob_header(s);
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2448 if(ret>=0)
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2449 return 0;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2450
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2451 s->gb= bak;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2452 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2453 skip_bits(&s->gb, 8);
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2454 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2455
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2456 return -1;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2457 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2458
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2459 /**
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2460 * @param n either 0 for the x component or 1 for y
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2461 * @returns the average MV for a GMC MB
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2462 */
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2463 static inline int get_amv(MpegEncContext *s, int n){
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2464 int x, y, mb_v, sum, dx, dy, shift;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2465 int len = 1 << (s->f_code + 4);
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2466 const int a= s->sprite_warping_accuracy;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2467
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2468 if(s->real_sprite_warping_points==1){
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2469 if(s->divx_version==500 && s->divx_build==413)
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2470 sum= s->sprite_offset[0][n] / (1<<(a - s->quarter_sample));
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2471 else
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2472 sum= RSHIFT(s->sprite_offset[0][n]<<s->quarter_sample, a);
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2473 }else{
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2474 dx= s->sprite_delta[n][0];
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2475 dy= s->sprite_delta[n][1];
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2476 shift= s->sprite_shift[0];
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2477 if(n) dy -= 1<<(shift + a + 1);
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2478 else dx -= 1<<(shift + a + 1);
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2479 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
2480
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2481 sum=0;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2482 for(y=0; y<16; y++){
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2483 int v;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2484
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2485 v= mb_v + dy*y;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2486 //XXX FIXME optimize
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2487 for(x=0; x<16; x++){
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2488 sum+= v>>shift;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2489 v+= dx;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2490 }
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2491 }
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2492 sum /= 256;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2493 sum= RSHIFT(sum<<s->quarter_sample, a);
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2494 }
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2495
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2496 if (sum < -len) sum= -len;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2497 else if (sum >= len) sum= len-1;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2498
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2499 return sum;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2500 }
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2501
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2502 /**
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2503 * decodes first partition.
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2504 * @return number of MBs decoded or <0 if an error occured
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2505 */
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2506 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
2507 int mb_num;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2508 static const INT8 quant_tab[4] = { -1, -2, 1, 2 };
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2509
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2510 /* decode first partition */
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2511 mb_num=0;
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2512 s->first_slice_line=1;
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2513 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
2514 ff_init_block_index(s);
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2515 for(; s->mb_x<s->mb_width; s->mb_x++){
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2516 const int xy= s->mb_x + s->mb_y*s->mb_width;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2517 int cbpc;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2518 int dir=0;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2519
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2520 mb_num++;
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2521 ff_update_block_index(s);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2522 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
2523 s->first_slice_line=0;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2524
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2525 if(s->mb_x==0) PRINT_MB_TYPE("\n");
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2526
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2527 if(s->pict_type==I_TYPE){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2528 int i;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2529
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2530 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
2531 return mb_num-1;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2532 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2533
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2534 PRINT_MB_TYPE("I");
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
2535 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
2536 if (cbpc < 0){
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2537
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2538 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
2539 return -1;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2540 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2541 s->cbp_table[xy]= cbpc & 3;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2542 s->mb_type[xy]= MB_TYPE_INTRA;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2543 s->mb_intra = 1;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2544
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2545 if(cbpc & 4) {
698
e050a053e259 h263_dc_scale() cleanup
michaelni
parents: 697
diff changeset
2546 change_qscale(s, quant_tab[get_bits(&s->gb, 2)]);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2547 }
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
2548 s->current_picture.qscale_table[xy]= s->qscale;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2549
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2550 s->mbintra_table[xy]= 1;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2551 for(i=0; i<6; i++){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2552 int dc_pred_dir;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2553 int dc= mpeg4_decode_dc(s, i, &dc_pred_dir);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2554 if(dc < 0){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2555 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
2556 return -1;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2557 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2558 dir<<=1;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2559 if(dc_pred_dir) dir|=1;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2560 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2561 s->pred_dir_table[xy]= dir;
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2562
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2563 s->error_status_table[xy]= AC_ERROR;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2564 }else{ /* P/S_TYPE */
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2565 int mx, my, pred_x, pred_y, bits;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2566 INT16 * const mot_val= s->motion_val[s->block_index[0]];
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2567 const int stride= s->block_wrap[0]*2;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2568
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2569 bits= show_bits(&s->gb, 17);
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2570 if(bits==MOTION_MARKER){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2571 return mb_num-1;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2572 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2573 skip_bits1(&s->gb);
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2574 if(bits&0x10000){
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2575 /* skip mb */
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2576 s->mb_type[xy]= MB_TYPE_SKIPED;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2577 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2578 PRINT_MB_TYPE("G");
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2579 mx= get_amv(s, 0);
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2580 my= get_amv(s, 1);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2581 }else{
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2582 PRINT_MB_TYPE("S");
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2583 mx=my=0;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2584 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2585 mot_val[0 ]= mot_val[2 ]=
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2586 mot_val[0+stride]= mot_val[2+stride]= mx;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2587 mot_val[1 ]= mot_val[3 ]=
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2588 mot_val[1+stride]= mot_val[3+stride]= my;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2589
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2590 if(s->mbintra_table[xy])
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2591 ff_clean_intra_table_entries(s);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2592
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2593 s->error_status_table[xy]= AC_ERROR;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2594 continue;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2595 }
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
2596 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
2597 if (cbpc < 0){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2598 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
2599 return -1;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2600 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2601 if (cbpc > 20)
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2602 cbpc+=3;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2603 else if (cbpc == 20)
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2604 fprintf(stderr, "Stuffing !");
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2605 s->cbp_table[xy]= cbpc&(8+3); //8 is dquant
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2606
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2607 s->mb_intra = ((cbpc & 4) != 0);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2608
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2609 if(s->mb_intra){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2610 PRINT_MB_TYPE("I");
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2611 s->mbintra_table[xy]= 1;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2612 s->mb_type[xy]= MB_TYPE_INTRA;
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]= 0;
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]= 0;
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2617 s->error_status_table[xy]= DC_ERROR|AC_ERROR;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2618 }else{
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2619 if(s->mbintra_table[xy])
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2620 ff_clean_intra_table_entries(s);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2621
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2622 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
2623 s->mcsel= get_bits1(&s->gb);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2624 else s->mcsel= 0;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2625
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2626 if ((cbpc & 16) == 0) {
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2627 PRINT_MB_TYPE("P");
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2628 /* 16x16 motion prediction */
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2629 s->mb_type[xy]= MB_TYPE_INTER;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2630
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2631 h263_pred_motion(s, 0, &pred_x, &pred_y);
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2632 if(!s->mcsel){
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2633 mx = h263_decode_motion(s, pred_x, s->f_code);
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2634 if (mx >= 0xffff)
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2635 return -1;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2636
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2637 my = h263_decode_motion(s, pred_y, s->f_code);
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2638 if (my >= 0xffff)
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2639 return -1;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2640 } else {
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2641 mx = get_amv(s, 0);
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2642 my = get_amv(s, 1);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2643 }
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2644
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2645 mot_val[0 ]= mot_val[2 ] =
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2646 mot_val[0+stride]= mot_val[2+stride]= mx;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2647 mot_val[1 ]= mot_val[3 ]=
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2648 mot_val[1+stride]= mot_val[3+stride]= my;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2649 } else {
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2650 int i;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2651 PRINT_MB_TYPE("4");
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2652 s->mb_type[xy]= MB_TYPE_INTER4V;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2653 for(i=0;i<4;i++) {
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2654 INT16 *mot_val= h263_pred_motion(s, i, &pred_x, &pred_y);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2655 mx = h263_decode_motion(s, pred_x, s->f_code);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2656 if (mx >= 0xffff)
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2657 return -1;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2658
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2659 my = h263_decode_motion(s, pred_y, s->f_code);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2660 if (my >= 0xffff)
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2661 return -1;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2662 mot_val[0] = mx;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2663 mot_val[1] = my;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2664 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2665 }
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2666 s->error_status_table[xy]= AC_ERROR;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2667 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2668 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2669 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2670 s->mb_x= 0;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2671 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2672
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2673 return mb_num;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2674 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2675
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2676 /**
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2677 * decode second partition.
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2678 * @return <0 if an error occured
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2679 */
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2680 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
2681 int mb_num=0;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2682 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
2683
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2684 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
2685 s->first_slice_line=1;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2686 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
2687 ff_init_block_index(s);
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2688 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
2689 const int xy= s->mb_x + s->mb_y*s->mb_width;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2690
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2691 mb_num++;
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2692 ff_update_block_index(s);
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2693 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
2694 s->first_slice_line=0;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2695
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2696 if(s->pict_type==I_TYPE){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2697 int ac_pred= get_bits1(&s->gb);
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
2698 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2699 if(cbpy<0){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2700 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
2701 return -1;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2702 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2703
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2704 s->cbp_table[xy]|= cbpy<<2;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2705 s->pred_dir_table[xy]|= ac_pred<<7;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2706 }else{ /* P || S_TYPE */
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2707 if(s->mb_type[xy]&MB_TYPE_INTRA){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2708 int dir=0,i;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2709 int ac_pred = get_bits1(&s->gb);
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
2710 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2711
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2712 if(cbpy<0){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2713 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
2714 return -1;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2715 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2716
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2717 if(s->cbp_table[xy] & 8) {
698
e050a053e259 h263_dc_scale() cleanup
michaelni
parents: 697
diff changeset
2718 change_qscale(s, quant_tab[get_bits(&s->gb, 2)]);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2719 }
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
2720 s->current_picture.qscale_table[xy]= s->qscale;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2721
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2722 for(i=0; i<6; i++){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2723 int dc_pred_dir;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2724 int dc= mpeg4_decode_dc(s, i, &dc_pred_dir);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2725 if(dc < 0){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2726 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
2727 return -1;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2728 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2729 dir<<=1;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2730 if(dc_pred_dir) dir|=1;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2731 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2732 s->cbp_table[xy]&= 3; //remove dquant
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2733 s->cbp_table[xy]|= cbpy<<2;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2734 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
2735 s->error_status_table[xy]&= ~DC_ERROR;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2736 }else if(s->mb_type[xy]&MB_TYPE_SKIPED){
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
2737 s->current_picture.qscale_table[xy]= s->qscale;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2738 s->cbp_table[xy]= 0;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2739 }else{
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
2740 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2741
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2742 if(cbpy<0){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2743 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
2744 return -1;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2745 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2746
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2747 if(s->cbp_table[xy] & 8) {
698
e050a053e259 h263_dc_scale() cleanup
michaelni
parents: 697
diff changeset
2748 change_qscale(s, quant_tab[get_bits(&s->gb, 2)]);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2749 }
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
2750 s->current_picture.qscale_table[xy]= s->qscale;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2751
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2752 s->cbp_table[xy]&= 3; //remove dquant
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2753 s->cbp_table[xy]|= (cbpy^0xf)<<2;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2754 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2755 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2756 }
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2757 if(mb_num >= mb_count) return 0;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2758 s->mb_x= 0;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2759 }
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2760 return 0;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2761 }
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 * decodes the first & second partition
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2765 * @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
2766 */
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2767 int ff_mpeg4_decode_partitions(MpegEncContext *s)
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2768 {
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2769 int mb_num;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2770
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2771 mb_num= mpeg4_decode_partition_a(s);
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2772 if(mb_num<0)
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2773 return -1;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2774
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2775 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
2776 fprintf(stderr, "slice below monitor ...\n");
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2777 return -1;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2778 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2779
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2780 s->mb_num_left= mb_num;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2781
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2782 if(s->pict_type==I_TYPE){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2783 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
2784 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
2785 return -1;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2786 }else
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2787 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
2788 }else{
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2789 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
2790 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
2791 return -1;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2792 }else
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2793 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
2794 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2795
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2796 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
2797 return -1;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2798 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2799
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2800 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
2801
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2802 return 0;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2803 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2804
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2805 /**
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2806 * decode partition C of one MB.
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2807 * @return <0 if an error occured
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2808 */
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2809 static int mpeg4_decode_partitioned_mb(MpegEncContext *s, DCTELEM block[6][64])
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2810 {
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2811 int cbp, mb_type;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2812 const int xy= s->mb_x + s->mb_y*s->mb_width;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2813
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2814 mb_type= s->mb_type[xy];
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2815 cbp = s->cbp_table[xy];
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2816
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
2817 if(s->current_picture.qscale_table[xy] != s->qscale){
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
2818 s->qscale= s->current_picture.qscale_table[xy];
698
e050a053e259 h263_dc_scale() cleanup
michaelni
parents: 697
diff changeset
2819 s->y_dc_scale= s->y_dc_scale_table[ s->qscale ];
e050a053e259 h263_dc_scale() cleanup
michaelni
parents: 697
diff changeset
2820 s->c_dc_scale= s->c_dc_scale_table[ s->qscale ];
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2821 }
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2822
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2823 if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2824 int i;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2825 for(i=0; i<4; i++){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2826 s->mv[0][i][0] = s->motion_val[ s->block_index[i] ][0];
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2827 s->mv[0][i][1] = s->motion_val[ s->block_index[i] ][1];
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2828 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2829 s->mb_intra = mb_type&MB_TYPE_INTRA;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2830
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2831 if (mb_type&MB_TYPE_SKIPED) {
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2832 /* skip mb */
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2833 for(i=0;i<6;i++)
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2834 s->block_last_index[i] = -1;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2835 s->mv_dir = MV_DIR_FORWARD;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2836 s->mv_type = MV_TYPE_16X16;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2837 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2838 s->mcsel=1;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2839 s->mb_skiped = 0;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2840 }else{
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2841 s->mcsel=0;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2842 s->mb_skiped = 1;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2843 }
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2844 }else if(s->mb_intra){
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2845 s->ac_pred = s->pred_dir_table[xy]>>7;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2846
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2847 /* decode each block */
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2848 for (i = 0; i < 6; i++) {
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2849 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
2850 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
2851 return -1;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2852 }
718
16dab8296293 fixing custom quantizer matrix decoding
michaelni
parents: 706
diff changeset
2853 cbp+=cbp;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2854 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2855 }else if(!s->mb_intra){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2856 // s->mcsel= 0; //FIXME do we need to init that
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2857
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2858 s->mv_dir = MV_DIR_FORWARD;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2859 if (mb_type&MB_TYPE_INTER4V) {
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2860 s->mv_type = MV_TYPE_8X8;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2861 } else {
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2862 s->mv_type = MV_TYPE_16X16;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2863 }
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2864 /* decode each block */
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2865 for (i = 0; i < 6; i++) {
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2866 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
2867 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
2868 return -1;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2869 }
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2870 cbp+=cbp;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2871 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2872 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2873 } else { /* I-Frame */
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2874 int i;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2875 s->mb_intra = 1;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2876 s->ac_pred = s->pred_dir_table[xy]>>7;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2877
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2878 /* decode each block */
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2879 for (i = 0; i < 6; i++) {
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2880 if(mpeg4_decode_block(s, block[i], i, cbp&32, 1) < 0){
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2881 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
2882 return -1;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2883 }
718
16dab8296293 fixing custom quantizer matrix decoding
michaelni
parents: 706
diff changeset
2884 cbp+=cbp;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2885 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2886 }
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2887
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2888 s->error_status_table[xy]&= ~AC_ERROR;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2889
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2890 /* per-MB end of slice check */
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2891
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2892 if(--s->mb_num_left <= 0){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2893 //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
2894 if(mpeg4_is_resync(s))
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2895 return SLICE_END;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2896 else
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2897 return SLICE_NOEND;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2898 }else{
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2899 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
2900 return SLICE_END;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2901 else
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2902 return SLICE_OK;
619
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
2903 }
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
2904 }
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2905
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2906 int ff_h263_decode_mb(MpegEncContext *s,
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2907 DCTELEM block[6][64])
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2908 {
986e461dc072 Initial revision
glantau
parents:
diff changeset
2909 int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2910 INT16 *mot_val;
110
e00e5d93457c Added Juergen Keil fix on quant_tab[4] type.
pulento
parents: 79
diff changeset
2911 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
2912
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2913 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
2914
523
c7e4c8b9a3c4 warning fix patch by atmos
michaelni
parents: 498
diff changeset
2915 if(s->mb_x==0) PRINT_MB_TYPE("\n");
359
df0736462b9f move ABS() to common.h
michaelni
parents: 358
diff changeset
2916
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
2917 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
2918 if (get_bits1(&s->gb)) {
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2919 /* skip mb */
986e461dc072 Initial revision
glantau
parents:
diff changeset
2920 s->mb_intra = 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2921 for(i=0;i<6;i++)
986e461dc072 Initial revision
glantau
parents:
diff changeset
2922 s->block_last_index[i] = -1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2923 s->mv_dir = MV_DIR_FORWARD;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2924 s->mv_type = MV_TYPE_16X16;
255
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
2925 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
359
df0736462b9f move ABS() to common.h
michaelni
parents: 358
diff changeset
2926 PRINT_MB_TYPE("G");
255
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
2927 s->mcsel=1;
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2928 s->mv[0][0][0]= get_amv(s, 0);
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2929 s->mv[0][0][1]= get_amv(s, 1);
255
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
2930
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
2931 s->mb_skiped = 0;
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
2932 }else{
359
df0736462b9f move ABS() to common.h
michaelni
parents: 358
diff changeset
2933 PRINT_MB_TYPE("S");
255
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
2934 s->mcsel=0;
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
2935 s->mv[0][0][0] = 0;
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
2936 s->mv[0][0][1] = 0;
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
2937 s->mb_skiped = 1;
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
2938 }
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2939 goto end;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2940 }
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
2941 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
2942 //fprintf(stderr, "\tCBPC: %d", cbpc);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2943 if (cbpc < 0)
986e461dc072 Initial revision
glantau
parents:
diff changeset
2944 return -1;
161
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
2945 if (cbpc > 20)
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
2946 cbpc+=3;
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
2947 else if (cbpc == 20)
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
2948 fprintf(stderr, "Stuffing !");
144
cb5dabd00ba2 - Bug fix on inter MCBPC table for inter+q.
pulento
parents: 110
diff changeset
2949
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2950 dquant = cbpc & 8;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2951 s->mb_intra = ((cbpc & 4) != 0);
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2952 if (s->mb_intra) goto intra;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2953
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
2954 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
2955 s->mcsel= get_bits1(&s->gb);
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
2956 else s->mcsel= 0;
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
2957 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2958 cbp = (cbpc & 3) | ((cbpy ^ 0xf) << 2);
986e461dc072 Initial revision
glantau
parents:
diff changeset
2959 if (dquant) {
698
e050a053e259 h263_dc_scale() cleanup
michaelni
parents: 697
diff changeset
2960 change_qscale(s, quant_tab[get_bits(&s->gb, 2)]);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2961 }
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2962 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
2963 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
2964
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2965 s->mv_dir = MV_DIR_FORWARD;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2966 if ((cbpc & 16) == 0) {
619
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
2967 if(s->mcsel){
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
2968 PRINT_MB_TYPE("G");
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
2969 /* 16x16 global motion prediction */
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
2970 s->mv_type = MV_TYPE_16X16;
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2971 mx= get_amv(s, 0);
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2972 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
2973 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
2974 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
2975 }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
2976 PRINT_MB_TYPE("f");
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
2977 /* 16x8 field motion prediction */
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
2978 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
2979
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
2980 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
2981 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
2982
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
2983 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
2984
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
2985 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
2986 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
2987 if (mx >= 0xffff)
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
2988 return -1;
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
2989
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
2990 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
2991 if (my >= 0xffff)
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
2992 return -1;
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
2993
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
2994 s->mv[0][i][0] = mx;
661
a0901e38c564 fixing interlaced mpeg4 decoding
michaelni
parents: 660
diff changeset
2995 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
2996 }
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
2997 }else{
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
2998 PRINT_MB_TYPE("P");
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
2999 /* 16x16 motion prediction */
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
3000 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
3001 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
3002 if (s->umvplus_dec)
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
3003 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
3004 else
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
3005 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
3006
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
3007 if (mx >= 0xffff)
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
3008 return -1;
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
3009
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
3010 if (s->umvplus_dec)
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
3011 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
3012 else
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
3013 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
3014
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
3015 if (my >= 0xffff)
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
3016 return -1;
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
3017 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
3018 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
3019
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
3020 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
3021 skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
255
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
3022 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3023 } else {
359
df0736462b9f move ABS() to common.h
michaelni
parents: 358
diff changeset
3024 PRINT_MB_TYPE("4");
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3025 s->mv_type = MV_TYPE_8X8;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3026 for(i=0;i<4;i++) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
3027 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
3028 if (s->umvplus_dec)
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3029 mx = h263p_decode_umotion(s, pred_x);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3030 else
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3031 mx = h263_decode_motion(s, pred_x, s->f_code);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3032 if (mx >= 0xffff)
986e461dc072 Initial revision
glantau
parents:
diff changeset
3033 return -1;
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3034
79
82e579c37bc3 Moved some H.263+ variables to MpegEncContext to be thread-safe.
pulento
parents: 78
diff changeset
3035 if (s->umvplus_dec)
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3036 my = h263p_decode_umotion(s, pred_y);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3037 else
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3038 my = h263_decode_motion(s, pred_y, s->f_code);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3039 if (my >= 0xffff)
986e461dc072 Initial revision
glantau
parents:
diff changeset
3040 return -1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3041 s->mv[0][i][0] = mx;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3042 s->mv[0][i][1] = my;
79
82e579c37bc3 Moved some H.263+ variables to MpegEncContext to be thread-safe.
pulento
parents: 78
diff changeset
3043 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
3044 skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3045 mot_val[0] = mx;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3046 mot_val[1] = my;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3047 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
3048 }
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3049 } else if(s->pict_type==B_TYPE) {
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3050 int modb1; // first bit of modb
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3051 int modb2; // second bit of modb
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3052 int mb_type;
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
3053 uint16_t time_pp;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
3054 uint16_t time_pb;
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3055 int xy;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3056
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3057 s->mb_intra = 0; //B-frames never contain intra blocks
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3058 s->mcsel=0; // ... true gmc blocks
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3059
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3060 if(s->mb_x==0){
674
4490bfbb932d interlaced b frames fix
michaelni
parents: 669
diff changeset
3061 for(i=0; i<2; i++){
4490bfbb932d interlaced b frames fix
michaelni
parents: 669
diff changeset
3062 s->last_mv[i][0][0]=
4490bfbb932d interlaced b frames fix
michaelni
parents: 669
diff changeset
3063 s->last_mv[i][0][1]=
4490bfbb932d interlaced b frames fix
michaelni
parents: 669
diff changeset
3064 s->last_mv[i][1][0]=
4490bfbb932d interlaced b frames fix
michaelni
parents: 669
diff changeset
3065 s->last_mv[i][1][1]= 0;
4490bfbb932d interlaced b frames fix
michaelni
parents: 669
diff changeset
3066 }
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3067 }
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3068
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3069 /* if we skipped it in the future P Frame than skip it now too */
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
3070 s->mb_skiped= s->next_picture.mbskip_table[s->mb_y * s->mb_width + s->mb_x]; // Note, skiptab=0 if last was GMC
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3071
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3072 if(s->mb_skiped){
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3073 /* skip mb */
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3074 for(i=0;i<6;i++)
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3075 s->block_last_index[i] = -1;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3076
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3077 s->mv_dir = MV_DIR_FORWARD;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3078 s->mv_type = MV_TYPE_16X16;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3079 s->mv[0][0][0] = 0;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3080 s->mv[0][0][1] = 0;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3081 s->mv[1][0][0] = 0;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3082 s->mv[1][0][1] = 0;
523
c7e4c8b9a3c4 warning fix patch by atmos
michaelni
parents: 498
diff changeset
3083 PRINT_MB_TYPE("s");
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3084 goto end;
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3085 }
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3086
666
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3087 modb1= get_bits1(&s->gb);
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3088 if(modb1){
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3089 mb_type=4; //like MB_TYPE_B_DIRECT but no vectors coded
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3090 cbp=0;
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3091 }else{
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3092 int field_mv;
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3093
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3094 modb2= get_bits1(&s->gb);
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
3095 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
3096 if(modb2) cbp= 0;
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3097 else cbp= get_bits(&s->gb, 6);
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3098
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3099 if (mb_type!=MB_TYPE_B_DIRECT && cbp) {
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3100 if(get_bits1(&s->gb)){
698
e050a053e259 h263_dc_scale() cleanup
michaelni
parents: 697
diff changeset
3101 change_qscale(s, get_bits1(&s->gb)*4 - 2);
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3102 }
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3103 }
666
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3104 field_mv=0;
664
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
3105
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
3106 if(!s->progressive_sequence){
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
3107 if(cbp)
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
3108 s->interlaced_dct= get_bits1(&s->gb);
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
3109
667
5446a41a00fe 10l (field select readed at the wrong place ...)
michaelni
parents: 666
diff changeset
3110 if(mb_type!=MB_TYPE_B_DIRECT && get_bits1(&s->gb)){
666
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3111 field_mv=1;
667
5446a41a00fe 10l (field select readed at the wrong place ...)
michaelni
parents: 666
diff changeset
3112
5446a41a00fe 10l (field select readed at the wrong place ...)
michaelni
parents: 666
diff changeset
3113 if(mb_type!=MB_TYPE_B_BACKW){
5446a41a00fe 10l (field select readed at the wrong place ...)
michaelni
parents: 666
diff changeset
3114 s->field_select[0][0]= get_bits1(&s->gb);
5446a41a00fe 10l (field select readed at the wrong place ...)
michaelni
parents: 666
diff changeset
3115 s->field_select[0][1]= get_bits1(&s->gb);
5446a41a00fe 10l (field select readed at the wrong place ...)
michaelni
parents: 666
diff changeset
3116 }
5446a41a00fe 10l (field select readed at the wrong place ...)
michaelni
parents: 666
diff changeset
3117 if(mb_type!=MB_TYPE_B_FORW){
5446a41a00fe 10l (field select readed at the wrong place ...)
michaelni
parents: 666
diff changeset
3118 s->field_select[1][0]= get_bits1(&s->gb);
5446a41a00fe 10l (field select readed at the wrong place ...)
michaelni
parents: 666
diff changeset
3119 s->field_select[1][1]= get_bits1(&s->gb);
5446a41a00fe 10l (field select readed at the wrong place ...)
michaelni
parents: 666
diff changeset
3120 }
5446a41a00fe 10l (field select readed at the wrong place ...)
michaelni
parents: 666
diff changeset
3121 }
666
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3122 }
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3123
667
5446a41a00fe 10l (field select readed at the wrong place ...)
michaelni
parents: 666
diff changeset
3124 s->mv_dir = 0;
666
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3125 if(mb_type!=MB_TYPE_B_DIRECT && !field_mv){
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3126 s->mv_type= MV_TYPE_16X16;
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3127 if(mb_type!=MB_TYPE_B_BACKW){
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3128 s->mv_dir = MV_DIR_FORWARD;
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3129
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3130 mx = h263_decode_motion(s, s->last_mv[0][0][0], s->f_code);
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3131 my = h263_decode_motion(s, s->last_mv[0][0][1], s->f_code);
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3132 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
3133 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
3134 }
666
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3135
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3136 if(mb_type!=MB_TYPE_B_FORW){
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3137 s->mv_dir |= MV_DIR_BACKWARD;
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3138
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3139 mx = h263_decode_motion(s, s->last_mv[1][0][0], s->b_code);
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3140 my = h263_decode_motion(s, s->last_mv[1][0][1], s->b_code);
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3141 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
3142 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
3143 }
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3144 if(mb_type!=MB_TYPE_B_DIRECT)
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3145 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
3146 }else if(mb_type!=MB_TYPE_B_DIRECT){
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3147 s->mv_type= MV_TYPE_FIELD;
667
5446a41a00fe 10l (field select readed at the wrong place ...)
michaelni
parents: 666
diff changeset
3148
666
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3149 if(mb_type!=MB_TYPE_B_BACKW){
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3150 s->mv_dir = MV_DIR_FORWARD;
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3151
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3152 for(i=0; i<2; i++){
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3153 mx = h263_decode_motion(s, s->last_mv[0][i][0] , s->f_code);
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3154 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
3155 s->last_mv[0][i][0]= s->mv[0][i][0] = mx;
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3156 s->last_mv[0][i][1]= (s->mv[0][i][1] = my)*2;
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3157 }
667
5446a41a00fe 10l (field select readed at the wrong place ...)
michaelni
parents: 666
diff changeset
3158 }
666
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3159
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3160 if(mb_type!=MB_TYPE_B_FORW){
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3161 s->mv_dir |= MV_DIR_BACKWARD;
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3162
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3163 for(i=0; i<2; i++){
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3164 mx = h263_decode_motion(s, s->last_mv[1][i][0] , s->b_code);
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3165 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
3166 s->last_mv[1][i][0]= s->mv[1][i][0] = mx;
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3167 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
3168 }
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
3169 }
666
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3170 if(mb_type!=MB_TYPE_B_DIRECT)
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3171 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
3172 }
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
3173 }
666
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3174
664
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
3175 if(mb_type==4 || mb_type==MB_TYPE_B_DIRECT){
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
3176 int mb_index= s->mb_x + s->mb_y*s->mb_width;
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
3177 int i;
666
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3178
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3179 if(mb_type==4)
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3180 mx=my=0;
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3181 else{
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3182 mx = h263_decode_motion(s, 0, 1);
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3183 my = h263_decode_motion(s, 0, 1);
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3184 }
664
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
3185
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3186 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
266
252444e5259b optimization
michaelni
parents: 265
diff changeset
3187 xy= s->block_index[0];
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
3188 time_pp= s->pp_time;
664
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
3189 time_pb= s->pb_time;
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
3190
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3191 //FIXME avoid divides
664
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
3192 switch(s->co_located_type_table[mb_index]){
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
3193 case 0:
666
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3194 s->mv_type= MV_TYPE_16X16;
664
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
3195 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
3196 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
3197 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
3198 : s->motion_val[xy][0]*(time_pb - time_pp)/time_pp;
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
3199 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
3200 : s->motion_val[xy][1]*(time_pb - time_pp)/time_pp;
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
3201 PRINT_MB_TYPE(mb_type==4 ? "D" : "S");
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
3202 break;
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
3203 case CO_LOCATED_TYPE_4MV:
598
0c950f816d61 4mv + bframe decoding bugfix
michaelni
parents: 597
diff changeset
3204 s->mv_type = MV_TYPE_8X8;
664
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
3205 for(i=0; i<4; i++){
598
0c950f816d61 4mv + bframe decoding bugfix
michaelni
parents: 597
diff changeset
3206 xy= s->block_index[i];
0c950f816d61 4mv + bframe decoding bugfix
michaelni
parents: 597
diff changeset
3207 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
3208 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
3209 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
3210 : s->motion_val[xy][0]*(time_pb - time_pp)/time_pp;
598
0c950f816d61 4mv + bframe decoding bugfix
michaelni
parents: 597
diff changeset
3211 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
3212 : s->motion_val[xy][1]*(time_pb - time_pp)/time_pp;
598
0c950f816d61 4mv + bframe decoding bugfix
michaelni
parents: 597
diff changeset
3213 }
0c950f816d61 4mv + bframe decoding bugfix
michaelni
parents: 597
diff changeset
3214 PRINT_MB_TYPE("4");
664
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
3215 break;
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
3216 case CO_LOCATED_TYPE_FIELDMV:
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
3217 s->mv_type = MV_TYPE_FIELD;
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
3218 for(i=0; i<2; i++){
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
3219 if(s->top_field_first){
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
3220 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
3221 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
3222 }else{
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
3223 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
3224 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
3225 }
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
3226 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
3227 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
3228 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
3229 : 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
3230 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
3231 : 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
3232 }
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
3233 PRINT_MB_TYPE("=");
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
3234 break;
598
0c950f816d61 4mv + bframe decoding bugfix
michaelni
parents: 597
diff changeset
3235 }
664
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
3236 }
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
3237
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
3238 if(mb_type<0 || mb_type>4){
364
6b6332e7008a segfault fix for b-frame encoding with height%16!=0
michaelni
parents: 360
diff changeset
3239 printf("illegal MB_type\n");
6b6332e7008a segfault fix for b-frame encoding with height%16!=0
michaelni
parents: 360
diff changeset
3240 return -1;
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3241 }
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3242 } else { /* I-Frame */
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
3243 cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 1);
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3244 if (cbpc < 0)
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3245 return -1;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3246 dquant = cbpc & 4;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3247 s->mb_intra = 1;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3248 intra:
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3249 s->ac_pred = 0;
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
3250 if (s->h263_pred || s->h263_aic) {
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
3251 s->ac_pred = get_bits1(&s->gb);
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
3252 if (s->ac_pred && s->h263_aic)
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
3253 s->h263_aic_dir = get_bits1(&s->gb);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3254 }
591
d3f374218030 fixing mpeg4 mpeg quantizers
michaelni
parents: 582
diff changeset
3255 PRINT_MB_TYPE(s->ac_pred ? "A" : "I");
d3f374218030 fixing mpeg4 mpeg quantizers
michaelni
parents: 582
diff changeset
3256
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
3257 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3258 if(cbpy<0) return -1;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3259 cbp = (cbpc & 3) | (cbpy << 2);
986e461dc072 Initial revision
glantau
parents:
diff changeset
3260 if (dquant) {
698
e050a053e259 h263_dc_scale() cleanup
michaelni
parents: 697
diff changeset
3261 change_qscale(s, quant_tab[get_bits(&s->gb, 2)]);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3262 }
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3263
619
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
3264 if(!s->progressive_sequence)
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
3265 s->interlaced_dct= get_bits1(&s->gb);
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
3266
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
3267 /* decode each block */
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
3268 if (s->h263_pred) {
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
3269 for (i = 0; i < 6; i++) {
718
16dab8296293 fixing custom quantizer matrix decoding
michaelni
parents: 706
diff changeset
3270 if (mpeg4_decode_block(s, block[i], i, cbp&32, 1) < 0)
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
3271 return -1;
718
16dab8296293 fixing custom quantizer matrix decoding
michaelni
parents: 706
diff changeset
3272 cbp+=cbp;
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
3273 }
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
3274 } else {
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
3275 for (i = 0; i < 6; i++) {
718
16dab8296293 fixing custom quantizer matrix decoding
michaelni
parents: 706
diff changeset
3276 if (h263_decode_block(s, block[i], i, cbp&32) < 0)
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
3277 return -1;
718
16dab8296293 fixing custom quantizer matrix decoding
michaelni
parents: 706
diff changeset
3278 cbp+=cbp;
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
3279 }
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
3280 }
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3281 goto end;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3282 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
3283
986e461dc072 Initial revision
glantau
parents:
diff changeset
3284 /* decode each block */
986e461dc072 Initial revision
glantau
parents:
diff changeset
3285 if (s->h263_pred) {
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
3286 for (i = 0; i < 6; i++) {
718
16dab8296293 fixing custom quantizer matrix decoding
michaelni
parents: 706
diff changeset
3287 if (mpeg4_decode_block(s, block[i], i, cbp&32, 0) < 0)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3288 return -1;
718
16dab8296293 fixing custom quantizer matrix decoding
michaelni
parents: 706
diff changeset
3289 cbp+=cbp;
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
3290 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3291 } else {
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
3292 for (i = 0; i < 6; i++) {
718
16dab8296293 fixing custom quantizer matrix decoding
michaelni
parents: 706
diff changeset
3293 if (h263_decode_block(s, block[i], i, cbp&32) < 0)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3294 return -1;
718
16dab8296293 fixing custom quantizer matrix decoding
michaelni
parents: 706
diff changeset
3295 cbp+=cbp;
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
3296 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3297 }
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3298 end:
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3299
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3300 /* per-MB end of slice check */
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3301 if(s->codec_id==CODEC_ID_MPEG4){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3302 if(mpeg4_is_resync(s)){
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
3303 if(s->pict_type==B_TYPE && s->next_picture.mbskip_table[s->mb_y * s->mb_width + s->mb_x+1])
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3304 return SLICE_OK;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3305 return SLICE_END;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3306 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3307 }else{
892
550033bc7e2d fixing h263+ slices if the padding at the end of the frame is >7 && <16 && there are no zero bytes afterwards
michaelni
parents: 887
diff changeset
3308 int v= show_bits(&s->gb, 16);
550033bc7e2d fixing h263+ slices if the padding at the end of the frame is >7 && <16 && there are no zero bytes afterwards
michaelni
parents: 887
diff changeset
3309
550033bc7e2d fixing h263+ slices if the padding at the end of the frame is >7 && <16 && there are no zero bytes afterwards
michaelni
parents: 887
diff changeset
3310 if(get_bits_count(&s->gb) + 16 > s->gb.size*8){
550033bc7e2d fixing h263+ slices if the padding at the end of the frame is >7 && <16 && there are no zero bytes afterwards
michaelni
parents: 887
diff changeset
3311 v>>= get_bits_count(&s->gb) + 16 - s->gb.size*8;
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3312 }
892
550033bc7e2d fixing h263+ slices if the padding at the end of the frame is >7 && <16 && there are no zero bytes afterwards
michaelni
parents: 887
diff changeset
3313
550033bc7e2d fixing h263+ slices if the padding at the end of the frame is >7 && <16 && there are no zero bytes afterwards
michaelni
parents: 887
diff changeset
3314 if(v==0)
550033bc7e2d fixing h263+ slices if the padding at the end of the frame is >7 && <16 && there are no zero bytes afterwards
michaelni
parents: 887
diff changeset
3315 return SLICE_END;
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3316 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3317
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3318 return SLICE_OK;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3319 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
3320
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3321 static int h263_decode_motion(MpegEncContext * s, int pred, int f_code)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3322 {
656
e47fa3e3f2d5 statistics for forw & back p-MBs instead of just one counter for both
michaelni
parents: 654
diff changeset
3323 int code, val, sign, shift, l;
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
3324 code = get_vlc2(&s->gb, mv_vlc.table, MV_VLC_BITS, 2);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3325 if (code < 0)
986e461dc072 Initial revision
glantau
parents:
diff changeset
3326 return 0xffff;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3327
986e461dc072 Initial revision
glantau
parents:
diff changeset
3328 if (code == 0)
986e461dc072 Initial revision
glantau
parents:
diff changeset
3329 return pred;
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
3330
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
3331 sign = get_bits1(&s->gb);
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3332 shift = f_code - 1;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3333 val = (code - 1) << shift;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3334 if (shift > 0)
986e461dc072 Initial revision
glantau
parents:
diff changeset
3335 val |= get_bits(&s->gb, shift);
986e461dc072 Initial revision
glantau
parents:
diff changeset
3336 val++;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3337 if (sign)
986e461dc072 Initial revision
glantau
parents:
diff changeset
3338 val = -val;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3339 val += pred;
475
6ccc48e4c41b run1 can be <0 bugfix (found by fabrice)
michaelni
parents: 469
diff changeset
3340
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3341 /* modulo decoding */
986e461dc072 Initial revision
glantau
parents:
diff changeset
3342 if (!s->h263_long_vectors) {
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
3343 l = 1 << (f_code + 4);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3344 if (val < -l) {
656
e47fa3e3f2d5 statistics for forw & back p-MBs instead of just one counter for both
michaelni
parents: 654
diff changeset
3345 val += l<<1;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3346 } else if (val >= l) {
656
e47fa3e3f2d5 statistics for forw & back p-MBs instead of just one counter for both
michaelni
parents: 654
diff changeset
3347 val -= l<<1;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3348 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
3349 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
3350 /* horrible h263 long vector mode */
986e461dc072 Initial revision
glantau
parents:
diff changeset
3351 if (pred < -31 && val < -63)
986e461dc072 Initial revision
glantau
parents:
diff changeset
3352 val += 64;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3353 if (pred > 32 && val > 63)
986e461dc072 Initial revision
glantau
parents:
diff changeset
3354 val -= 64;
154
f914f710b8d0 - Fixed a bug on H.263 MV prediction for MB on GOBs limits.
pulento
parents: 144
diff changeset
3355
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3356 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
3357 return val;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3358 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
3359
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3360 /* Decodes RVLC of H.263+ UMV */
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3361 static int h263p_decode_umotion(MpegEncContext * s, int pred)
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3362 {
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3363 int code = 0, sign;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3364
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3365 if (get_bits1(&s->gb)) /* Motion difference = 0 */
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3366 return pred;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3367
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3368 code = 2 + get_bits1(&s->gb);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3369
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3370 while (get_bits1(&s->gb))
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3371 {
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3372 code <<= 1;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3373 code += get_bits1(&s->gb);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3374 }
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3375 sign = code & 1;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3376 code >>= 1;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3377
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3378 code = (sign) ? (pred - code) : (pred + code);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3379 #ifdef DEBUG
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3380 fprintf(stderr,"H.263+ UMV Motion = %d\n", code);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3381 #endif
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3382 return code;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3383
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3384 }
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3385
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3386 static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
986e461dc072 Initial revision
glantau
parents:
diff changeset
3387 int n, int coded)
986e461dc072 Initial revision
glantau
parents:
diff changeset
3388 {
986e461dc072 Initial revision
glantau
parents:
diff changeset
3389 int code, level, i, j, last, run;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3390 RLTable *rl = &rl_inter;
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
3391 const UINT8 *scan_table;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3392
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
3393 scan_table = s->intra_scantable.permutated;
249
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
3394 if (s->h263_aic && s->mb_intra) {
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
3395 rl = &rl_intra_aic;
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
3396 i = 0;
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
3397 if (s->ac_pred) {
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
3398 if (s->h263_aic_dir)
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
3399 scan_table = s->intra_v_scantable.permutated; /* left */
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
3400 else
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
3401 scan_table = s->intra_h_scantable.permutated; /* top */
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
3402 }
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
3403 } else if (s->mb_intra) {
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
3404 /* DC coef */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3405 if (s->h263_rv10 && s->rv10_version == 3 && s->pict_type == I_TYPE) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
3406 int component, diff;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3407 component = (n <= 3 ? 0 : n - 4 + 1);
986e461dc072 Initial revision
glantau
parents:
diff changeset
3408 level = s->last_dc[component];
986e461dc072 Initial revision
glantau
parents:
diff changeset
3409 if (s->rv10_first_dc_coded[component]) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
3410 diff = rv_decode_dc(s, n);
986e461dc072 Initial revision
glantau
parents:
diff changeset
3411 if (diff == 0xffff)
986e461dc072 Initial revision
glantau
parents:
diff changeset
3412 return -1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3413 level += diff;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3414 level = level & 0xff; /* handle wrap round */
986e461dc072 Initial revision
glantau
parents:
diff changeset
3415 s->last_dc[component] = level;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3416 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
3417 s->rv10_first_dc_coded[component] = 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3418 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
3419 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
3420 level = get_bits(&s->gb, 8);
986e461dc072 Initial revision
glantau
parents:
diff changeset
3421 if (level == 255)
986e461dc072 Initial revision
glantau
parents:
diff changeset
3422 level = 128;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3423 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
3424 block[0] = level;
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
3425 i = 1;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3426 } else {
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
3427 i = 0;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3428 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
3429 if (!coded) {
249
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
3430 if (s->mb_intra && s->h263_aic)
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
3431 goto not_coded;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3432 s->block_last_index[n] = i - 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3433 return 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3434 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
3435
986e461dc072 Initial revision
glantau
parents:
diff changeset
3436 for(;;) {
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
3437 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
3438 if (code < 0){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3439 fprintf(stderr, "illegal ac vlc code at %dx%d\n", s->mb_x, s->mb_y);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3440 return -1;
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3441 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3442 if (code == rl->n) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
3443 /* escape */
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
3444 last = get_bits1(&s->gb);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3445 run = get_bits(&s->gb, 6);
986e461dc072 Initial revision
glantau
parents:
diff changeset
3446 level = (INT8)get_bits(&s->gb, 8);
986e461dc072 Initial revision
glantau
parents:
diff changeset
3447 if (s->h263_rv10 && level == -128) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
3448 /* XXX: should patch encoder too */
986e461dc072 Initial revision
glantau
parents:
diff changeset
3449 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
3450 level= (level + ((-1)<<11)) ^ ((-1)<<11); //sign extension
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3451 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
3452 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
3453 run = rl->table_run[code];
986e461dc072 Initial revision
glantau
parents:
diff changeset
3454 level = rl->table_level[code];
986e461dc072 Initial revision
glantau
parents:
diff changeset
3455 last = code >= rl->last;
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
3456 if (get_bits1(&s->gb))
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3457 level = -level;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3458 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
3459 i += run;
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3460 if (i >= 64){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3461 fprintf(stderr, "run overflow at %dx%d\n", s->mb_x, s->mb_y);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3462 return -1;
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3463 }
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
3464 j = scan_table[i];
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3465 block[j] = level;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3466 if (last)
986e461dc072 Initial revision
glantau
parents:
diff changeset
3467 break;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3468 i++;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3469 }
249
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
3470 not_coded:
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
3471 if (s->mb_intra && s->h263_aic) {
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
3472 h263_pred_acdc(s, block, n);
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
3473 i = 63;
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
3474 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3475 s->block_last_index[n] = i;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3476 return 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3477 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
3478
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3479 static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3480 {
986e461dc072 Initial revision
glantau
parents:
diff changeset
3481 int level, pred, code;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3482 UINT16 *dc_val;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3483
986e461dc072 Initial revision
glantau
parents:
diff changeset
3484 if (n < 4)
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
3485 code = get_vlc2(&s->gb, dc_lum.table, DC_VLC_BITS, 1);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3486 else
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
3487 code = get_vlc2(&s->gb, dc_chrom.table, DC_VLC_BITS, 1);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3488 if (code < 0 || code > 9 /* && s->nbit<9 */){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3489 fprintf(stderr, "illegal dc vlc\n");
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3490 return -1;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3491 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3492 if (code == 0) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
3493 level = 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3494 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
3495 level = get_bits(&s->gb, code);
986e461dc072 Initial revision
glantau
parents:
diff changeset
3496 if ((level >> (code - 1)) == 0) /* if MSB not set it is negative*/
986e461dc072 Initial revision
glantau
parents:
diff changeset
3497 level = - (level ^ ((1 << code) - 1));
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3498 if (code > 8){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3499 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
3500 if(s->error_resilience>=2){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3501 fprintf(stderr, "dc marker bit missing\n");
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3502 return -1;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3503 }
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3504 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3505 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3506 }
498
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
3507 pred = ff_mpeg4_pred_dc(s, n, &dc_val, dir_ptr);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3508 level += pred;
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3509 if (level < 0){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3510 if(s->error_resilience>=3){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3511 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
3512 return -1;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3513 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3514 level = 0;
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3515 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3516 if (n < 4) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
3517 *dc_val = level * s->y_dc_scale;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3518 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
3519 *dc_val = level * s->c_dc_scale;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3520 }
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3521 if(s->error_resilience>=3){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3522 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
3523 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
3524 return -1;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3525 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3526 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3527 return level;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3528 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
3529
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3530 /**
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3531 * decodes a block.
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3532 * @return <0 if an error occured
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3533 */
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3534 static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
3535 int n, int coded, int intra)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3536 {
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3537 int level, i, last, run;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3538 int dc_pred_dir;
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
3539 RLTable * rl;
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
3540 RL_VLC_ELEM * rl_vlc;
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
3541 const UINT8 * scan_table;
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3542 int qmul, qadd;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3543
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
3544 if(intra) {
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3545 /* DC coef */
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3546 if(s->partitioned_frame){
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3547 level = s->dc_val[0][ s->block_index[n] ];
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3548 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
3549 else level= (level + (s->c_dc_scale>>1))/s->c_dc_scale;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3550 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
3551 }else{
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3552 level = mpeg4_decode_dc(s, n, &dc_pred_dir);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3553 if (level < 0)
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3554 return -1;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3555 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3556 block[0] = level;
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3557 i = 0;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3558 if (!coded)
986e461dc072 Initial revision
glantau
parents:
diff changeset
3559 goto not_coded;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3560 rl = &rl_intra;
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3561 rl_vlc = rl_intra.rl_vlc[0];
718
16dab8296293 fixing custom quantizer matrix decoding
michaelni
parents: 706
diff changeset
3562 if (s->ac_pred) {
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3563 if (dc_pred_dir == 0)
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
3564 scan_table = s->intra_v_scantable.permutated; /* left */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3565 else
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
3566 scan_table = s->intra_h_scantable.permutated; /* top */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3567 } else {
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
3568 scan_table = s->intra_scantable.permutated;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3569 }
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3570 qmul=1;
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3571 qadd=0;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3572 } else {
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3573 i = -1;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3574 if (!coded) {
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3575 s->block_last_index[n] = i;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3576 return 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3577 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
3578 rl = &rl_inter;
661
a0901e38c564 fixing interlaced mpeg4 decoding
michaelni
parents: 660
diff changeset
3579
718
16dab8296293 fixing custom quantizer matrix decoding
michaelni
parents: 706
diff changeset
3580 scan_table = s->intra_scantable.permutated;
661
a0901e38c564 fixing interlaced mpeg4 decoding
michaelni
parents: 660
diff changeset
3581
591
d3f374218030 fixing mpeg4 mpeg quantizers
michaelni
parents: 582
diff changeset
3582 if(s->mpeg_quant){
d3f374218030 fixing mpeg4 mpeg quantizers
michaelni
parents: 582
diff changeset
3583 qmul=1;
d3f374218030 fixing mpeg4 mpeg quantizers
michaelni
parents: 582
diff changeset
3584 qadd=0;
d3f374218030 fixing mpeg4 mpeg quantizers
michaelni
parents: 582
diff changeset
3585 rl_vlc = rl_inter.rl_vlc[0];
d3f374218030 fixing mpeg4 mpeg quantizers
michaelni
parents: 582
diff changeset
3586 }else{
d3f374218030 fixing mpeg4 mpeg quantizers
michaelni
parents: 582
diff changeset
3587 qmul = s->qscale << 1;
d3f374218030 fixing mpeg4 mpeg quantizers
michaelni
parents: 582
diff changeset
3588 qadd = (s->qscale - 1) | 1;
d3f374218030 fixing mpeg4 mpeg quantizers
michaelni
parents: 582
diff changeset
3589 rl_vlc = rl_inter.rl_vlc[s->qscale];
d3f374218030 fixing mpeg4 mpeg quantizers
michaelni
parents: 582
diff changeset
3590 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3591 }
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3592 {
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3593 OPEN_READER(re, &s->gb);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3594 for(;;) {
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3595 UPDATE_CACHE(re, &s->gb);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3596 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3597 if (level==0) {
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3598 int cache;
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3599 cache= GET_CACHE(re, &s->gb);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3600 /* escape */
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3601 if (cache&0x80000000) {
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3602 if (cache&0x40000000) {
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3603 /* third escape */
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3604 SKIP_CACHE(re, &s->gb, 2);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3605 last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3606 run= SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3607 SKIP_COUNTER(re, &s->gb, 2+1+6);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3608 UPDATE_CACHE(re, &s->gb);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3609
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3610 if(SHOW_UBITS(re, &s->gb, 1)==0){
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3611 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
3612 return -1;
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3613 }; SKIP_CACHE(re, &s->gb, 1);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3614
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3615 level= SHOW_SBITS(re, &s->gb, 12); SKIP_CACHE(re, &s->gb, 12);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3616
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3617 if(SHOW_UBITS(re, &s->gb, 1)==0){
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3618 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
3619 return -1;
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3620 }; LAST_SKIP_CACHE(re, &s->gb, 1);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3621
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3622 SKIP_COUNTER(re, &s->gb, 1+12+1);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3623
597
d5d0c11ea4cf fixing level overflow check for qp=1
michaelni
parents: 591
diff changeset
3624 if(level*s->qscale>1024 || level*s->qscale<-1024){
d5d0c11ea4cf fixing level overflow check for qp=1
michaelni
parents: 591
diff changeset
3625 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
3626 return -1;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3627 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3628 #if 1
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3629 {
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3630 const int abs_level= ABS(level);
921
f633377858b6 ump4 decoding fixed
michaelni
parents: 906
diff changeset
3631 if(abs_level<=MAX_LEVEL && run<=MAX_RUN && !(s->workaround_bugs&FF_BUG_AC_VLC)){
498
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
3632 const int run1= run - rl->max_run[last][abs_level] - 1;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3633 if(abs_level <= rl->max_level[last][run]){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3634 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
3635 return -1;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3636 }
905
2b93dc762f9a fixing illegal 3. esc bug (the mpeg4 std only requires encoders to use unescaped symbols but not esc1 or esc2 if they are shorter than esc3, andjust beause its logical to use the shortest possible vlc doesnt mean encoders do that)
michaelni
parents: 903
diff changeset
3637 if(s->error_resilience > FF_ER_COMPLIANT){
2b93dc762f9a fixing illegal 3. esc bug (the mpeg4 std only requires encoders to use unescaped symbols but not esc1 or esc2 if they are shorter than esc3, andjust beause its logical to use the shortest possible vlc doesnt mean encoders do that)
michaelni
parents: 903
diff changeset
3638 if(abs_level <= rl->max_level[last][run]*2){
2b93dc762f9a fixing illegal 3. esc bug (the mpeg4 std only requires encoders to use unescaped symbols but not esc1 or esc2 if they are shorter than esc3, andjust beause its logical to use the shortest possible vlc doesnt mean encoders do that)
michaelni
parents: 903
diff changeset
3639 fprintf(stderr, "illegal 3. esc, esc 1 encoding possible\n");
2b93dc762f9a fixing illegal 3. esc bug (the mpeg4 std only requires encoders to use unescaped symbols but not esc1 or esc2 if they are shorter than esc3, andjust beause its logical to use the shortest possible vlc doesnt mean encoders do that)
michaelni
parents: 903
diff changeset
3640 return -1;
2b93dc762f9a fixing illegal 3. esc bug (the mpeg4 std only requires encoders to use unescaped symbols but not esc1 or esc2 if they are shorter than esc3, andjust beause its logical to use the shortest possible vlc doesnt mean encoders do that)
michaelni
parents: 903
diff changeset
3641 }
2b93dc762f9a fixing illegal 3. esc bug (the mpeg4 std only requires encoders to use unescaped symbols but not esc1 or esc2 if they are shorter than esc3, andjust beause its logical to use the shortest possible vlc doesnt mean encoders do that)
michaelni
parents: 903
diff changeset
3642 if(run1 >= 0 && abs_level <= rl->max_level[last][run1]){
2b93dc762f9a fixing illegal 3. esc bug (the mpeg4 std only requires encoders to use unescaped symbols but not esc1 or esc2 if they are shorter than esc3, andjust beause its logical to use the shortest possible vlc doesnt mean encoders do that)
michaelni
parents: 903
diff changeset
3643 fprintf(stderr, "illegal 3. esc, esc 2 encoding possible\n");
2b93dc762f9a fixing illegal 3. esc bug (the mpeg4 std only requires encoders to use unescaped symbols but not esc1 or esc2 if they are shorter than esc3, andjust beause its logical to use the shortest possible vlc doesnt mean encoders do that)
michaelni
parents: 903
diff changeset
3644 return -1;
2b93dc762f9a fixing illegal 3. esc bug (the mpeg4 std only requires encoders to use unescaped symbols but not esc1 or esc2 if they are shorter than esc3, andjust beause its logical to use the shortest possible vlc doesnt mean encoders do that)
michaelni
parents: 903
diff changeset
3645 }
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3646 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3647 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3648 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3649 #endif
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3650 if (level>0) level= level * qmul + qadd;
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3651 else level= level * qmul - qadd;
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3652
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3653 i+= run + 1;
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3654 if(last) i+=192;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3655 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
3656 /* second escape */
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3657 #if MIN_CACHE_BITS < 20
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3658 LAST_SKIP_BITS(re, &s->gb, 2);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3659 UPDATE_CACHE(re, &s->gb);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3660 #else
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3661 SKIP_BITS(re, &s->gb, 2);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3662 #endif
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3663 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3664 i+= run + rl->max_run[run>>7][level/qmul] +1; //FIXME opt indexing
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3665 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3666 LAST_SKIP_BITS(re, &s->gb, 1);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3667 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
3668 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
3669 /* first escape */
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3670 #if MIN_CACHE_BITS < 19
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3671 LAST_SKIP_BITS(re, &s->gb, 1);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3672 UPDATE_CACHE(re, &s->gb);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3673 #else
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3674 SKIP_BITS(re, &s->gb, 1);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3675 #endif
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3676 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3677 i+= run;
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3678 level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//FIXME opt indexing
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3679 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3680 LAST_SKIP_BITS(re, &s->gb, 1);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3681 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
3682 } else {
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3683 i+= run;
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3684 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3685 LAST_SKIP_BITS(re, &s->gb, 1);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3686 }
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3687 if (i > 62){
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3688 i-= 192;
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3689 if(i&(~63)){
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3690 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
3691 return -1;
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3692 }
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3693
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3694 block[scan_table[i]] = level;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3695 break;
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3696 }
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3697
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3698 block[scan_table[i]] = level;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3699 }
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3700 CLOSE_READER(re, &s->gb);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3701 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3702 not_coded:
986e461dc072 Initial revision
glantau
parents:
diff changeset
3703 if (s->mb_intra) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
3704 mpeg4_pred_ac(s, block, n, dc_pred_dir);
986e461dc072 Initial revision
glantau
parents:
diff changeset
3705 if (s->ac_pred) {
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3706 i = 63; /* XXX: not optimal */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3707 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
3708 }
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3709 s->block_last_index[n] = i;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3710 return 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3711 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
3712
986e461dc072 Initial revision
glantau
parents:
diff changeset
3713 /* most is hardcoded. should extend to handle all h263 streams */
986e461dc072 Initial revision
glantau
parents:
diff changeset
3714 int h263_decode_picture_header(MpegEncContext *s)
986e461dc072 Initial revision
glantau
parents:
diff changeset
3715 {
986e461dc072 Initial revision
glantau
parents:
diff changeset
3716 int format, width, height;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3717
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3718 /* picture start code */
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3719 if (get_bits(&s->gb, 22) != 0x20) {
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3720 fprintf(stderr, "Bad picture start code\n");
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3721 return -1;
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3722 }
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3723 /* temporal reference */
231
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
3724 s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3725
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3726 /* PTYPE starts here */
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3727 if (get_bits1(&s->gb) != 1) {
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3728 /* marker */
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3729 fprintf(stderr, "Bad marker\n");
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3730 return -1;
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3731 }
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, "Bad H263 id\n");
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3734 return -1; /* h263 id */
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3735 }
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
3736 skip_bits1(&s->gb); /* split screen off */
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
3737 skip_bits1(&s->gb); /* camera off */
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
3738 skip_bits1(&s->gb); /* freeze picture release off */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3739
155
3c3449bce692 - Bug fix on MV prediction for MPEG4 caused by new H.263 GOB code.
pulento
parents: 154
diff changeset
3740 /* Reset GOB number */
154
f914f710b8d0 - Fixed a bug on H.263 MV prediction for MB on GOBs limits.
pulento
parents: 144
diff changeset
3741 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
3742
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3743 format = get_bits(&s->gb, 3);
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3744 /*
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3745 0 forbidden
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3746 1 sub-QCIF
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3747 10 QCIF
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3748 7 extended PTYPE (PLUSPTYPE)
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3749 */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3750
161
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3751 if (format != 7 && format != 6) {
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3752 s->h263_plus = 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3753 /* H.263v1 */
986e461dc072 Initial revision
glantau
parents:
diff changeset
3754 width = h263_format[format][0];
986e461dc072 Initial revision
glantau
parents:
diff changeset
3755 height = h263_format[format][1];
986e461dc072 Initial revision
glantau
parents:
diff changeset
3756 if (!width)
986e461dc072 Initial revision
glantau
parents:
diff changeset
3757 return -1;
161
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3758
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3759 s->width = width;
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3760 s->height = height;
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
3761 s->pict_type = I_TYPE + get_bits1(&s->gb);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3762
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
3763 s->unrestricted_mv = get_bits1(&s->gb);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3764 s->h263_long_vectors = s->unrestricted_mv;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3765
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3766 if (get_bits1(&s->gb) != 0) {
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3767 fprintf(stderr, "H263 SAC not supported\n");
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3768 return -1; /* SAC: off */
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3769 }
161
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3770 if (get_bits1(&s->gb) != 0) {
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3771 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
3772 }
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3773
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3774 if (get_bits1(&s->gb) != 0) {
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3775 fprintf(stderr, "H263 PB frame not supported\n");
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3776 return -1; /* not PB frame */
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3777 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3778 s->qscale = get_bits(&s->gb, 5);
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
3779 skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3780 } else {
161
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3781 int ufep;
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3782
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3783 /* H.263v2 */
161
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3784 s->h263_plus = 1;
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3785 ufep = get_bits(&s->gb, 3); /* Update Full Extended PTYPE */
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3786
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3787 /* 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
3788 if (ufep == 1) {
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3789 /* OPPTYPE */
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3790 format = get_bits(&s->gb, 3);
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3791 dprintf("ufep=1, format: %d\n", format);
161
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3792 skip_bits(&s->gb,1); /* Custom PCF */
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3793 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
3794 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
3795 if (get_bits1(&s->gb) != 0) {
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3796 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
3797 }
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
3798 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
3799 s->h263_aic = 1;
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
3800 }
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3801
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
3802 skip_bits(&s->gb, 7);
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3803 /* these are the 7 bits: (in order of appearence */
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3804 /* Deblocking Filter */
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3805 /* Slice Structured */
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3806 /* Reference Picture Selection */
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3807 /* Independent Segment Decoding */
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3808 /* Alternative Inter VLC */
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3809 /* Modified Quantization */
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3810 /* Prevent start code emulation */
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3811
161
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3812 skip_bits(&s->gb, 3); /* Reserved */
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3813 } else if (ufep != 0) {
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3814 fprintf(stderr, "Bad UFEP type (%d)\n", ufep);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3815 return -1;
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3816 }
161
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3817
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3818 /* MPPTYPE */
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3819 s->pict_type = get_bits(&s->gb, 3) + I_TYPE;
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3820 dprintf("pict_type: %d\n", s->pict_type);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3821 if (s->pict_type != I_TYPE &&
986e461dc072 Initial revision
glantau
parents:
diff changeset
3822 s->pict_type != P_TYPE)
986e461dc072 Initial revision
glantau
parents:
diff changeset
3823 return -1;
250
3449316664b5 - Bug fix on RTYPE (rounding type) not being honoured by H.263+ decoder.
pulento
parents: 249
diff changeset
3824 skip_bits(&s->gb, 2);
3449316664b5 - Bug fix on RTYPE (rounding type) not being honoured by H.263+ decoder.
pulento
parents: 249
diff changeset
3825 s->no_rounding = get_bits1(&s->gb);
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3826 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
3827 skip_bits(&s->gb, 4);
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3828
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3829 /* Get the picture dimensions */
161
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3830 if (ufep) {
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3831 if (format == 6) {
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3832 /* Custom Picture Format (CPFMT) */
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3833 s->aspect_ratio_info = get_bits(&s->gb, 4);
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3834 dprintf("aspect: %d\n", s->aspect_ratio_info);
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3835 /* aspect ratios:
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3836 0 - forbidden
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3837 1 - 1:1
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3838 2 - 12:11 (CIF 4:3)
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3839 3 - 10:11 (525-type 4:3)
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3840 4 - 16:11 (CIF 16:9)
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3841 5 - 40:33 (525-type 16:9)
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3842 6-14 - reserved
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3843 */
161
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3844 width = (get_bits(&s->gb, 9) + 1) * 4;
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3845 skip_bits1(&s->gb);
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3846 height = get_bits(&s->gb, 9) * 4;
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3847 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
3848 if (s->aspect_ratio_info == FF_ASPECT_EXTENDED) {
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3849 /* aspected dimensions */
669
b4bddbde44f3 aspect (ext. par too) support for h263 and mpeg4 (inc. build becouse of new vars)
al3x
parents: 667
diff changeset
3850 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
3851 s->aspected_height = get_bits(&s->gb, 8);
887
19f5b8b7c6d5 fixing aspect
michaelni
parents: 880
diff changeset
3852 }else{
19f5b8b7c6d5 fixing aspect
michaelni
parents: 880
diff changeset
3853 s->aspected_width = pixel_aspect[s->aspect_ratio_info][0];
19f5b8b7c6d5 fixing aspect
michaelni
parents: 880
diff changeset
3854 s->aspected_height= pixel_aspect[s->aspect_ratio_info][1];
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3855 }
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3856 } else {
161
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3857 width = h263_format[format][0];
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3858 height = h263_format[format][1];
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3859 }
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3860 if ((width == 0) || (height == 0))
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3861 return -1;
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3862 s->width = width;
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3863 s->height = height;
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3864 if (s->umvplus_dec) {
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3865 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
3866 }
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3867 }
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3868
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3869 s->qscale = get_bits(&s->gb, 5);
986e461dc072 Initial revision
glantau
parents:
diff changeset
3870 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
3871 /* PEI */
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
3872 while (get_bits1(&s->gb) != 0) {
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
3873 skip_bits(&s->gb, 8);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3874 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
3875 s->f_code = 1;
498
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
3876
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
3877 if(s->h263_aic){
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
3878 s->y_dc_scale_table=
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
3879 s->c_dc_scale_table= h263_aic_dc_scale_table;
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
3880 }else{
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
3881 s->y_dc_scale_table=
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
3882 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
3883 }
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
3884
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3885 return 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3886 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
3887
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3888 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
3889 {
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3890 int i;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3891 int a= 2<<s->sprite_warping_accuracy;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3892 int rho= 3-s->sprite_warping_accuracy;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3893 int r=16/a;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3894 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
3895 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
3896 int sprite_ref[4][2];
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3897 int virtual_ref[2][2];
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3898 int w2, h2, w3, h3;
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3899 int alpha=0, beta=0;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3900 int w= s->width;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3901 int h= s->height;
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3902 int min_ab;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3903
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3904 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
3905 int length;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3906 int x=0, y=0;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3907
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3908 length= get_vlc(&s->gb, &sprite_trajectory);
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3909 if(length){
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3910 x= get_bits(&s->gb, length);
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3911
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3912 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
3913 x = - (x ^ ((1 << length) - 1));
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3914 }
255
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
3915 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
3916
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3917 length= get_vlc(&s->gb, &sprite_trajectory);
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3918 if(length){
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3919 y=get_bits(&s->gb, length);
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3920
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3921 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
3922 y = - (y ^ ((1 << length) - 1));
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3923 }
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3924 skip_bits1(&s->gb); /* marker bit */
255
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
3925 //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
3926 d[i][0]= x;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3927 d[i][1]= y;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3928 }
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3929
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3930 while((1<<alpha)<w) alpha++;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3931 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
3932 w2= 1<<alpha;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3933 h2= 1<<beta;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3934
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3935 // Note, the 4th point isnt used for GMC
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3936 if(s->divx_version==500 && s->divx_build==413){
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3937 sprite_ref[0][0]= a*vop_ref[0][0] + d[0][0];
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3938 sprite_ref[0][1]= a*vop_ref[0][1] + d[0][1];
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3939 sprite_ref[1][0]= a*vop_ref[1][0] + d[0][0] + d[1][0];
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3940 sprite_ref[1][1]= a*vop_ref[1][1] + d[0][1] + d[1][1];
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3941 sprite_ref[2][0]= a*vop_ref[2][0] + d[0][0] + d[2][0];
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3942 sprite_ref[2][1]= a*vop_ref[2][1] + d[0][1] + d[2][1];
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3943 } else {
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3944 sprite_ref[0][0]= (a>>1)*(2*vop_ref[0][0] + d[0][0]);
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3945 sprite_ref[0][1]= (a>>1)*(2*vop_ref[0][1] + d[0][1]);
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3946 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
3947 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
3948 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
3949 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
3950 }
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3951 /* 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
3952 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
3953
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3954 // 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
3955 // 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
3956 // 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
3957 // 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
3958 virtual_ref[0][0]= 16*(vop_ref[0][0] + w2)
359
df0736462b9f move ABS() to common.h
michaelni
parents: 358
diff changeset
3959 + 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
3960 virtual_ref[0][1]= 16*vop_ref[0][1]
359
df0736462b9f move ABS() to common.h
michaelni
parents: 358
diff changeset
3961 + 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
3962 virtual_ref[1][0]= 16*vop_ref[0][0]
359
df0736462b9f move ABS() to common.h
michaelni
parents: 358
diff changeset
3963 + 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
3964 virtual_ref[1][1]= 16*(vop_ref[0][1] + h2)
359
df0736462b9f move ABS() to common.h
michaelni
parents: 358
diff changeset
3965 + 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
3966
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3967 switch(s->num_sprite_warping_points)
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3968 {
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3969 case 0:
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3970 s->sprite_offset[0][0]= 0;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3971 s->sprite_offset[0][1]= 0;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3972 s->sprite_offset[1][0]= 0;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3973 s->sprite_offset[1][1]= 0;
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3974 s->sprite_delta[0][0]= a;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3975 s->sprite_delta[0][1]= 0;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3976 s->sprite_delta[1][0]= 0;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3977 s->sprite_delta[1][1]= a;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3978 s->sprite_shift[0]= 0;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3979 s->sprite_shift[1]= 0;
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3980 break;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3981 case 1: //GMC only
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3982 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
3983 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
3984 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
3985 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
3986 s->sprite_delta[0][0]= a;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3987 s->sprite_delta[0][1]= 0;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3988 s->sprite_delta[1][0]= 0;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3989 s->sprite_delta[1][1]= a;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3990 s->sprite_shift[0]= 0;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3991 s->sprite_shift[1]= 0;
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3992 break;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3993 case 2:
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3994 s->sprite_offset[0][0]= (sprite_ref[0][0]<<(alpha+rho))
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3995 + (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][0])
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3996 + ( r*sprite_ref[0][1] - virtual_ref[0][1])*(-vop_ref[0][1])
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3997 + (1<<(alpha+rho-1));
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3998 s->sprite_offset[0][1]= (sprite_ref[0][1]<<(alpha+rho))
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3999 + (-r*sprite_ref[0][1] + virtual_ref[0][1])*(-vop_ref[0][0])
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4000 + (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][1])
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4001 + (1<<(alpha+rho-1));
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4002 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
4003 +( 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
4004 +2*w2*r*sprite_ref[0][0]
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4005 - 16*w2
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4006 + (1<<(alpha+rho+1)));
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4007 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
4008 +(-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
4009 +2*w2*r*sprite_ref[0][1]
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4010 - 16*w2
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4011 + (1<<(alpha+rho+1)));
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4012 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
4013 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
4014 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
4015 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
4016
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4017 s->sprite_shift[0]= alpha+rho;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4018 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
4019 break;
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4020 case 3:
847
f3c369b8ddca reversing header game
michaelni
parents: 821
diff changeset
4021 min_ab= FFMIN(alpha, beta);
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4022 w3= w2>>min_ab;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4023 h3= h2>>min_ab;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4024 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
4025 + (-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
4026 + (-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
4027 + (1<<(alpha+beta+rho-min_ab-1));
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4028 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
4029 + (-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
4030 + (-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
4031 + (1<<(alpha+beta+rho-min_ab-1));
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4032 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
4033 + (-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
4034 + 2*w2*h3*r*sprite_ref[0][0]
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4035 - 16*w2*h3
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4036 + (1<<(alpha+beta+rho-min_ab+1));
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4037 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
4038 + (-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
4039 + 2*w2*h3*r*sprite_ref[0][1]
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4040 - 16*w2*h3
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4041 + (1<<(alpha+beta+rho-min_ab+1));
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4042 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
4043 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
4044 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
4045 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
4046
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4047 s->sprite_shift[0]= alpha + beta + rho - min_ab;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4048 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
4049 break;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
4050 }
255
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
4051 /* try to simplify the situation */
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4052 if( s->sprite_delta[0][0] == a<<s->sprite_shift[0]
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4053 && s->sprite_delta[0][1] == 0
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4054 && s->sprite_delta[1][0] == 0
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4055 && s->sprite_delta[1][1] == a<<s->sprite_shift[0])
255
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
4056 {
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4057 s->sprite_offset[0][0]>>=s->sprite_shift[0];
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4058 s->sprite_offset[0][1]>>=s->sprite_shift[0];
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4059 s->sprite_offset[1][0]>>=s->sprite_shift[1];
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4060 s->sprite_offset[1][1]>>=s->sprite_shift[1];
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4061 s->sprite_delta[0][0]= a;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4062 s->sprite_delta[0][1]= 0;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4063 s->sprite_delta[1][0]= 0;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4064 s->sprite_delta[1][1]= a;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4065 s->sprite_shift[0]= 0;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4066 s->sprite_shift[1]= 0;
255
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
4067 s->real_sprite_warping_points=1;
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
4068 }
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4069 else{
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4070 int shift_y= 16 - s->sprite_shift[0];
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4071 int shift_c= 16 - s->sprite_shift[1];
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4072 //printf("shifts %d %d\n", shift_y, shift_c);
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4073 for(i=0; i<2; i++){
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4074 s->sprite_offset[0][i]<<= shift_y;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4075 s->sprite_offset[1][i]<<= shift_c;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4076 s->sprite_delta[0][i]<<= shift_y;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4077 s->sprite_delta[1][i]<<= shift_y;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4078 s->sprite_shift[i]= 16;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4079 }
255
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
4080 s->real_sprite_warping_points= s->num_sprite_warping_points;
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4081 }
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4082 #if 0
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4083 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
4084 vop_ref[0][0], vop_ref[0][1],
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4085 vop_ref[1][0], vop_ref[1][1],
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4086 vop_ref[2][0], vop_ref[2][1],
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4087 sprite_ref[0][0], sprite_ref[0][1],
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4088 sprite_ref[1][0], sprite_ref[1][1],
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4089 sprite_ref[2][0], sprite_ref[2][1],
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4090 virtual_ref[0][0], virtual_ref[0][1],
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4091 virtual_ref[1][0], virtual_ref[1][1]
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4092 );
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4093
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4094 printf("offset: %d:%d , delta: %d %d %d %d, shift %d\n",
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4095 s->sprite_offset[0][0], s->sprite_offset[0][1],
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4096 s->sprite_delta[0][0], s->sprite_delta[0][1],
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4097 s->sprite_delta[1][0], s->sprite_delta[1][1],
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4098 s->sprite_shift[0]
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4099 );
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4100 #endif
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
4101 }
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
4102
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4103 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
4104 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
4105
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4106 /* vol header */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4107 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
4108 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
4109 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
4110 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
4111 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
4112 } else {
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4113 vo_ver_id = 1;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4114 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4115 //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
4116 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
4117 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
4118 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
4119 s->aspected_height = get_bits(gb, 8); // par_height
887
19f5b8b7c6d5 fixing aspect
michaelni
parents: 880
diff changeset
4120 }else{
19f5b8b7c6d5 fixing aspect
michaelni
parents: 880
diff changeset
4121 s->aspected_width = pixel_aspect[s->aspect_ratio_info][0];
19f5b8b7c6d5 fixing aspect
michaelni
parents: 880
diff changeset
4122 s->aspected_height= pixel_aspect[s->aspect_ratio_info][1];
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4123 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4124
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4125 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
4126 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
4127 if(chroma_format!=1){
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4128 printf("illegal chroma format\n");
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 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
4131 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
4132 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
4133 skip_bits1(gb); /* marker */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4134 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
4135 skip_bits1(gb); /* marker */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4136 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
4137 skip_bits1(gb); /* marker */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4138 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
4139 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
4140 skip_bits1(gb); /* marker */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4141 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
4142 skip_bits1(gb); /* marker */
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 }else{
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4145 // 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
4146 if(s->picture_number==0)
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4147 s->low_delay=0;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4148 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4149
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4150 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
4151 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
4152 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
4153 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
4154 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
4155 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4156
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
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4159 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
4160
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4161 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
4162 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
4163 s->time_increment_bits = 1;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4164 skip_bits1(gb); /* marker */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4165
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4166 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
4167 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
4168 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4169
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4170 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
4171 if (s->shape == RECT_SHAPE) {
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4172 skip_bits1(gb); /* marker */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4173 width = get_bits(gb, 13);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4174 skip_bits1(gb); /* marker */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4175 height = get_bits(gb, 13);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4176 skip_bits1(gb); /* marker */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4177 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
4178 s->width = width;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4179 s->height = height;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4180 // 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
4181 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4182 }
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 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
4185 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
4186 if (vo_ver_id == 1) {
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4187 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
4188 } else {
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4189 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
4190 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4191 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
4192 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
4193 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
4194 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
4195 skip_bits1(gb); /* marker */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4196 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
4197 skip_bits1(gb); /* marker */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4198 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
4199 skip_bits1(gb); /* marker */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4200 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
4201 skip_bits1(gb); /* marker */
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 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
4204 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
4205 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
4206 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
4207 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
4208 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4209 // 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
4210
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4211 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
4212 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
4213 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
4214 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
4215 } else {
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4216 s->quant_precision = 5;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4217 }
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4218
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4219 // 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
4220
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4221 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
4222 int i, j, v;
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 /* load default matrixes */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4225 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
4226 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
4227 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
4228 s->intra_matrix[j]= v;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4229 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
4230
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4231 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
4232 s->inter_matrix[j]= v;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4233 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
4234 }
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 /* load custom intra matrix */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4237 if(get_bits1(gb)){
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4238 int last=0;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4239 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
4240 v= get_bits(gb, 8);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4241 if(v==0) break;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4242
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4243 last= v;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4244 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
4245 s->intra_matrix[j]= v;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4246 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
4247 }
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 /* replicate last value */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4250 for(; i<64; i++){
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4251 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
4252 s->intra_matrix[j]= v;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4253 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
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 /* load custom non intra matrix */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4258 if(get_bits1(gb)){
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4259 int last=0;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4260 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
4261 v= get_bits(gb, 8);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4262 if(v==0) break;
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 last= v;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4265 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
4266 s->inter_matrix[j]= v;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4267 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
4268 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4269
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4270 /* replicate last value */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4271 for(; i<64; i++){
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4272 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
4273 s->inter_matrix[j]= last;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4274 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
4275 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4276 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4277
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4278 // 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
4279 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4280
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4281 if(vo_ver_id != 1)
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4282 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
4283 else s->quarter_sample=0;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4284
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4285 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
4286
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4287 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
4288
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4289 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
4290 if(s->data_partitioning){
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4291 s->rvlc= get_bits1(gb);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4292 if(s->rvlc){
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4293 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
4294 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4295 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4296
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4297 if(vo_ver_id != 1) {
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4298 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
4299 if(s->new_pred){
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4300 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
4301 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
4302 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
4303 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4304 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
4305 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
4306 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4307 else{
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4308 s->new_pred=0;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4309 s->reduced_res_vop= 0;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4310 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4311
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4312 s->scalability= get_bits1(gb);
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 if (s->scalability) {
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4315 GetBitContext bak= *gb;
751
cbe316f082bc warning fixes
michaelni
parents: 747
diff changeset
4316 int ref_layer_id;
cbe316f082bc warning fixes
michaelni
parents: 747
diff changeset
4317 int ref_layer_sampling_dir;
cbe316f082bc warning fixes
michaelni
parents: 747
diff changeset
4318 int h_sampling_factor_n;
cbe316f082bc warning fixes
michaelni
parents: 747
diff changeset
4319 int h_sampling_factor_m;
cbe316f082bc warning fixes
michaelni
parents: 747
diff changeset
4320 int v_sampling_factor_n;
cbe316f082bc warning fixes
michaelni
parents: 747
diff changeset
4321 int v_sampling_factor_m;
cbe316f082bc warning fixes
michaelni
parents: 747
diff changeset
4322
cbe316f082bc warning fixes
michaelni
parents: 747
diff changeset
4323 s->hierachy_type= get_bits1(gb);
cbe316f082bc warning fixes
michaelni
parents: 747
diff changeset
4324 ref_layer_id= get_bits(gb, 4);
cbe316f082bc warning fixes
michaelni
parents: 747
diff changeset
4325 ref_layer_sampling_dir= get_bits1(gb);
cbe316f082bc warning fixes
michaelni
parents: 747
diff changeset
4326 h_sampling_factor_n= get_bits(gb, 5);
cbe316f082bc warning fixes
michaelni
parents: 747
diff changeset
4327 h_sampling_factor_m= get_bits(gb, 5);
cbe316f082bc warning fixes
michaelni
parents: 747
diff changeset
4328 v_sampling_factor_n= get_bits(gb, 5);
cbe316f082bc warning fixes
michaelni
parents: 747
diff changeset
4329 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
4330 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
4331
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4332 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
4333 || 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
4334
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4335 // 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
4336 s->scalability=0;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4337
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4338 *gb= bak;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4339 }else
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4340 printf("scalability not supported\n");
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4341
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4342 // bin shape stuff FIXME
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 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4345 return 0;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4346 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4347
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4348 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
4349 char buf[256];
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4350 int i;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4351 int e;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4352 int ver, build, ver2, ver3;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4353
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4354 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
4355 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
4356 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
4357 if(buf[i]==0) break;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4358 skip_bits(gb, 8);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4359 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4360 buf[255]=0;
761
7f4cc2f6d642 xvid qpel bug autodetect
michaelni
parents: 757
diff changeset
4361
7f4cc2f6d642 xvid qpel bug autodetect
michaelni
parents: 757
diff changeset
4362 /* divx detection */
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4363 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
4364 if(e!=2)
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4365 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
4366 if(e==2){
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4367 s->divx_version= ver;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4368 s->divx_build= build;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4369 if(s->picture_number==0){
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4370 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
4371 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4372 }
761
7f4cc2f6d642 xvid qpel bug autodetect
michaelni
parents: 757
diff changeset
4373
7f4cc2f6d642 xvid qpel bug autodetect
michaelni
parents: 757
diff changeset
4374 /* ffmpeg detection */
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4375 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
4376 if(e!=4)
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4377 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
4378 if(e!=4){
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4379 if(strcmp(buf, "ffmpeg")==0){
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4380 s->ffmpeg_version= 0x000406;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4381 s->lavc_build= 4600;
63
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
4382 }
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4383 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4384 if(e==4){
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4385 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
4386 s->lavc_build= build;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4387 if(s->picture_number==0)
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4388 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
4389 }
761
7f4cc2f6d642 xvid qpel bug autodetect
michaelni
parents: 757
diff changeset
4390
7f4cc2f6d642 xvid qpel bug autodetect
michaelni
parents: 757
diff changeset
4391 /* xvid detection */
7f4cc2f6d642 xvid qpel bug autodetect
michaelni
parents: 757
diff changeset
4392 e=sscanf(buf, "XviD%d", &build);
7f4cc2f6d642 xvid qpel bug autodetect
michaelni
parents: 757
diff changeset
4393 if(e==1){
7f4cc2f6d642 xvid qpel bug autodetect
michaelni
parents: 757
diff changeset
4394 s->xvid_build= build;
7f4cc2f6d642 xvid qpel bug autodetect
michaelni
parents: 757
diff changeset
4395 if(s->picture_number==0)
7f4cc2f6d642 xvid qpel bug autodetect
michaelni
parents: 757
diff changeset
4396 printf("This file was encoded with XviD build %d\n", build);
7f4cc2f6d642 xvid qpel bug autodetect
michaelni
parents: 757
diff changeset
4397 }
7f4cc2f6d642 xvid qpel bug autodetect
michaelni
parents: 757
diff changeset
4398
255
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
4399 //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
4400 return 0;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4401 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4402
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4403 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
4404 int time_incr, time_increment;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4405
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4406 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
4407 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
4408 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
4409 s->low_delay=0;
fdeec2834c79 there are divx5? encoded files without a userdata section but with b-frames :(
michaelni
parents: 364
diff changeset
4410 }
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4411
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
4412 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
4413 if(s->partitioned_frame)
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
4414 s->decode_mb= mpeg4_decode_partitioned_mb;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
4415 else
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
4416 s->decode_mb= ff_h263_decode_mb;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
4417
662
5a158f0d1981 fixing 1/0 if the headers are incomplete (like what M$ encoder generates)
michaelni
parents: 661
diff changeset
4418 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
4419 s->time_increment_resolution=1;
5a158f0d1981 fixing 1/0 if the headers are incomplete (like what M$ encoder generates)
michaelni
parents: 661
diff changeset
4420 // 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
4421 }
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
4422 time_incr=0;
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4423 while (get_bits1(gb) != 0)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4424 time_incr++;
986e461dc072 Initial revision
glantau
parents:
diff changeset
4425
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4426 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
4427 time_increment= get_bits(gb, s->time_increment_bits);
697
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
4428 //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
4429 if(s->pict_type!=B_TYPE){
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
4430 s->last_time_base= s->time_base;
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
4431 s->time_base+= time_incr;
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
4432 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
4433 if(s->workaround_bugs&FF_BUG_UMP4){
700
0fb4c66527e1 autodetect UMP4 (by adding a fourcc field to AVCodecContext)
michaelni
parents: 699
diff changeset
4434 if(s->time < s->last_non_b_time){
0fb4c66527e1 autodetect UMP4 (by adding a fourcc field to AVCodecContext)
michaelni
parents: 699
diff changeset
4435 // 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
4436 s->time_base++;
0fb4c66527e1 autodetect UMP4 (by adding a fourcc field to AVCodecContext)
michaelni
parents: 699
diff changeset
4437 s->time+= s->time_increment_resolution;
0fb4c66527e1 autodetect UMP4 (by adding a fourcc field to AVCodecContext)
michaelni
parents: 699
diff changeset
4438 }
664
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
4439 }
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
4440 s->pp_time= s->time - s->last_non_b_time;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
4441 s->last_non_b_time= s->time;
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
4442 }else{
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
4443 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
4444 s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
4445 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
4446 // printf("messed up order, seeking?, skiping current b frame\n");
e7e9d9901523 b-frame mpeg4 fix when seeking
michaelni
parents: 333
diff changeset
4447 return FRAME_SKIPED;
e7e9d9901523 b-frame mpeg4 fix when seeking
michaelni
parents: 333
diff changeset
4448 }
664
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
4449
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
4450 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
4451 if(s->t_frame==0) s->t_frame=1; // 1/0 protection
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
4452 //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
4453 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
4454 - 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
4455 s->pb_field_time= ( ROUNDED_DIV(s->time, s->t_frame)
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
4456 - ROUNDED_DIV(s->last_non_b_time - s->pp_time, s->t_frame))*2;
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
4457 }
654
850098147a3c export pts from stream if available
michaelni
parents: 648
diff changeset
4458
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
4459 s->current_picture.pts= s->time*1000LL*1000LL / s->time_increment_resolution;
654
850098147a3c export pts from stream if available
michaelni
parents: 648
diff changeset
4460
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4461 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
4462 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
4463 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
4464 if(get_bits1(gb)) break;
264
28c5c62b1c4c support decoding (with mplayer) of 3 .mp4 files from mphq
michaelni
parents: 263
diff changeset
4465 }
28c5c62b1c4c support decoding (with mplayer) of 3 .mp4 files from mphq
michaelni
parents: 263
diff changeset
4466 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
4467 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4468 /* vop coded */
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4469 if (get_bits1(gb) != 1){
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4470 printf("vop not coded\n");
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4471 return FRAME_SKIPED;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4472 }
664
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
4473 //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
4474 //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
4475 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
4476 || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE))) {
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4477 /* 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
4478 s->no_rounding = get_bits1(gb);
63
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
4479 } else {
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
4480 s->no_rounding = 0;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4481 }
253
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
4482 //FIXME reduced res stuff
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
4483
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
4484 if (s->shape != RECT_SHAPE) {
63
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
4485 if (s->vol_sprite_usage != 1 || s->pict_type != I_TYPE) {
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
4486 int width, height, hor_spat_ref, ver_spat_ref;
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
4487
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4488 width = get_bits(gb, 13);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4489 skip_bits1(gb); /* marker */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4490 height = get_bits(gb, 13);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4491 skip_bits1(gb); /* marker */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4492 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
4493 skip_bits1(gb); /* marker */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4494 ver_spat_ref = get_bits(gb, 13); /* ver_spat_ref */
63
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
4495 }
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4496 skip_bits1(gb); /* change_CR_disable */
63
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
4497
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4498 if (get_bits1(gb) != 0) {
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4499 skip_bits(gb, 8); /* constant_alpha_value */
63
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
4500 }
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
4501 }
253
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
4502 //FIXME complexity estimation stuff
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
4503
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
4504 if (s->shape != BIN_ONLY_SHAPE) {
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
4505 int t;
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4506 t=get_bits(gb, 3); /* intra dc VLC threshold */
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
4507 //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
4508 if(!s->progressive_sequence){
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4509 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
4510 s->alternate_scan= get_bits1(gb);
661
a0901e38c564 fixing interlaced mpeg4 decoding
michaelni
parents: 660
diff changeset
4511 }else
a0901e38c564 fixing interlaced mpeg4 decoding
michaelni
parents: 660
diff changeset
4512 s->alternate_scan= 0;
253
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
4513 }
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
4514
718
16dab8296293 fixing custom quantizer matrix decoding
michaelni
parents: 706
diff changeset
4515 if(s->alternate_scan){
16dab8296293 fixing custom quantizer matrix decoding
michaelni
parents: 706
diff changeset
4516 ff_init_scantable(s, &s->inter_scantable , ff_alternate_vertical_scan);
16dab8296293 fixing custom quantizer matrix decoding
michaelni
parents: 706
diff changeset
4517 ff_init_scantable(s, &s->intra_scantable , ff_alternate_vertical_scan);
16dab8296293 fixing custom quantizer matrix decoding
michaelni
parents: 706
diff changeset
4518 ff_init_scantable(s, &s->intra_h_scantable, ff_alternate_vertical_scan);
16dab8296293 fixing custom quantizer matrix decoding
michaelni
parents: 706
diff changeset
4519 ff_init_scantable(s, &s->intra_v_scantable, ff_alternate_vertical_scan);
16dab8296293 fixing custom quantizer matrix decoding
michaelni
parents: 706
diff changeset
4520 } else{
16dab8296293 fixing custom quantizer matrix decoding
michaelni
parents: 706
diff changeset
4521 ff_init_scantable(s, &s->inter_scantable , ff_zigzag_direct);
16dab8296293 fixing custom quantizer matrix decoding
michaelni
parents: 706
diff changeset
4522 ff_init_scantable(s, &s->intra_scantable , ff_zigzag_direct);
16dab8296293 fixing custom quantizer matrix decoding
michaelni
parents: 706
diff changeset
4523 ff_init_scantable(s, &s->intra_h_scantable, ff_alternate_horizontal_scan);
16dab8296293 fixing custom quantizer matrix decoding
michaelni
parents: 706
diff changeset
4524 ff_init_scantable(s, &s->intra_v_scantable, ff_alternate_vertical_scan);
16dab8296293 fixing custom quantizer matrix decoding
michaelni
parents: 706
diff changeset
4525 }
16dab8296293 fixing custom quantizer matrix decoding
michaelni
parents: 706
diff changeset
4526
253
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
4527 if(s->pict_type == S_TYPE && (s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE)){
821
f5f2e162331c hopefully fixing sprite_warping_points==0
michaelni
parents: 815
diff changeset
4528 mpeg4_decode_sprite_trajectory(s);
253
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
4529 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
4530 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
4531 }
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
4532
253
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
4533 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
4534 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
4535 if(s->qscale==0){
28c5c62b1c4c support decoding (with mplayer) of 3 .mp4 files from mphq
michaelni
parents: 263
diff changeset
4536 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
4537 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
4538 }
63
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
4539
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
4540 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
4541 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
4542 if(s->f_code==0){
28c5c62b1c4c support decoding (with mplayer) of 3 .mp4 files from mphq
michaelni
parents: 263
diff changeset
4543 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
4544 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
4545 }
582
5132a4ee50cd different edge positions fixed with edge emu / dr1
michaelni
parents: 575
diff changeset
4546 }else
5132a4ee50cd different edge positions fixed with edge emu / dr1
michaelni
parents: 575
diff changeset
4547 s->f_code=1;
5132a4ee50cd different edge positions fixed with edge emu / dr1
michaelni
parents: 575
diff changeset
4548
253
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
4549 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
4550 s->b_code = get_bits(gb, 3);
582
5132a4ee50cd different edge positions fixed with edge emu / dr1
michaelni
parents: 575
diff changeset
4551 }else
5132a4ee50cd different edge positions fixed with edge emu / dr1
michaelni
parents: 575
diff changeset
4552 s->b_code=1;
906
bbe0c99231a7 specific debug output support
michaelni
parents: 905
diff changeset
4553
bbe0c99231a7 specific debug output support
michaelni
parents: 905
diff changeset
4554 if(s->avctx->debug&FF_DEBUG_PICT_INFO){
930
6bcb214d6a17 more debug output
michaelni
parents: 923
diff changeset
4555 printf("qp:%d fc:%d,%d %s size:%d pro:%d alt:%d top:%d %spel part:%d resync:%d w:%d a:%d\n",
906
bbe0c99231a7 specific debug output support
michaelni
parents: 905
diff changeset
4556 s->qscale, s->f_code, s->b_code,
bbe0c99231a7 specific debug output support
michaelni
parents: 905
diff changeset
4557 s->pict_type == I_TYPE ? "I" : (s->pict_type == P_TYPE ? "P" : (s->pict_type == B_TYPE ? "B" : "S")),
bbe0c99231a7 specific debug output support
michaelni
parents: 905
diff changeset
4558 gb->size,s->progressive_sequence, s->alternate_scan, s->top_field_first,
930
6bcb214d6a17 more debug output
michaelni
parents: 923
diff changeset
4559 s->quarter_sample ? "q" : "h", s->data_partitioning, s->resync_marker, s->num_sprite_warping_points,
906
bbe0c99231a7 specific debug output support
michaelni
parents: 905
diff changeset
4560 s->sprite_warping_accuracy);
bbe0c99231a7 specific debug output support
michaelni
parents: 905
diff changeset
4561 }
bbe0c99231a7 specific debug output support
michaelni
parents: 905
diff changeset
4562
253
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
4563 if(!s->scalability){
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
4564 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
4565 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
4566 }
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
4567 }else{
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
4568 if(s->enhancement_type){
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4569 int load_backward_shape= get_bits1(gb);
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
4570 if(load_backward_shape){
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
4571 printf("load backward shape isnt supported\n");
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
4572 }
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
4573 }
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4574 skip_bits(gb, 2); //ref_select_code
63
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
4575 }
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
4576 }
346
c2f789fe4945 detecting xvid/divx4/opendivx and set low_delay flag
michaelni
parents: 344
diff changeset
4577 /* 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
4578 // 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
4579 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
4580 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
4581 s->low_delay=1;
c2f789fe4945 detecting xvid/divx4/opendivx and set low_delay flag
michaelni
parents: 344
diff changeset
4582 }
c2f789fe4945 detecting xvid/divx4/opendivx and set low_delay flag
michaelni
parents: 344
diff changeset
4583
255
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
4584 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
4585
498
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
4586 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
4587 s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
4588
582
5132a4ee50cd different edge positions fixed with edge emu / dr1
michaelni
parents: 575
diff changeset
4589 if(s->divx_version==0 || s->divx_version < 500){
5132a4ee50cd different edge positions fixed with edge emu / dr1
michaelni
parents: 575
diff changeset
4590 s->h_edge_pos= s->width;
5132a4ee50cd different edge positions fixed with edge emu / dr1
michaelni
parents: 575
diff changeset
4591 s->v_edge_pos= s->height;
5132a4ee50cd different edge positions fixed with edge emu / dr1
michaelni
parents: 575
diff changeset
4592 }
63
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
4593 return 0;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4594 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
4595
747
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 * decode mpeg4 headers
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4598 * @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
4599 * 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
4600 * 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
4601 */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4602 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
4603 {
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4604 int startcode, v;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4605
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4606 /* search next start code */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4607 align_get_bits(gb);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4608 startcode = 0xff;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4609 for(;;) {
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4610 v = get_bits(gb, 8);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4611 startcode = ((startcode << 8) | v) & 0xffffffff;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4612
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4613 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
4614 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
4615 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
4616 return FRAME_SKIPED; //divx bug
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4617 }else
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4618 return -1; //end of stream
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4619 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4620
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4621 if((startcode&0xFFFFFF00) != 0x100)
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4622 continue; //no startcode
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4623
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4624 switch(startcode){
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4625 case 0x120:
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4626 decode_vol_header(s, gb);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4627 break;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4628 case 0x1b2:
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4629 decode_user_data(s, gb);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4630 break;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4631 case 0x1b6:
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4632 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
4633 default:
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4634 // 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
4635 break;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4636 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4637
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4638 align_get_bits(gb);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4639 startcode = 0xff;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4640 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4641 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4642
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4643 /* don't understand why they choose a different header ! */
986e461dc072 Initial revision
glantau
parents:
diff changeset
4644 int intel_h263_decode_picture_header(MpegEncContext *s)
986e461dc072 Initial revision
glantau
parents:
diff changeset
4645 {
986e461dc072 Initial revision
glantau
parents:
diff changeset
4646 int format;
986e461dc072 Initial revision
glantau
parents:
diff changeset
4647
986e461dc072 Initial revision
glantau
parents:
diff changeset
4648 /* picture header */
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4649 if (get_bits(&s->gb, 22) != 0x20) {
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4650 fprintf(stderr, "Bad picture start code\n");
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4651 return -1;
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4652 }
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4653 s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4654
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4655 if (get_bits1(&s->gb) != 1) {
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4656 fprintf(stderr, "Bad marker\n");
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4657 return -1; /* marker */
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4658 }
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4659 if (get_bits1(&s->gb) != 0) {
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4660 fprintf(stderr, "Bad H263 id\n");
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4661 return -1; /* h263 id */
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4662 }
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
4663 skip_bits1(&s->gb); /* split screen off */
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
4664 skip_bits1(&s->gb); /* camera off */
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
4665 skip_bits1(&s->gb); /* freeze picture release off */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4666
986e461dc072 Initial revision
glantau
parents:
diff changeset
4667 format = get_bits(&s->gb, 3);
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4668 if (format != 7) {
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4669 fprintf(stderr, "Intel H263 free format not supported\n");
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4670 return -1;
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4671 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4672 s->h263_plus = 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
4673
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
4674 s->pict_type = I_TYPE + get_bits1(&s->gb);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4675
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
4676 s->unrestricted_mv = get_bits1(&s->gb);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4677 s->h263_long_vectors = s->unrestricted_mv;
986e461dc072 Initial revision
glantau
parents:
diff changeset
4678
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4679 if (get_bits1(&s->gb) != 0) {
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4680 fprintf(stderr, "SAC not supported\n");
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4681 return -1; /* SAC: off */
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4682 }
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4683 if (get_bits1(&s->gb) != 0) {
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4684 fprintf(stderr, "Advanced Prediction Mode not supported\n");
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4685 return -1; /* advanced prediction mode: off */
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4686 }
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4687 if (get_bits1(&s->gb) != 0) {
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4688 fprintf(stderr, "PB frame mode no supported\n");
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4689 return -1; /* PB frame mode */
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4690 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4691
986e461dc072 Initial revision
glantau
parents:
diff changeset
4692 /* skip unknown header garbage */
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
4693 skip_bits(&s->gb, 41);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4694
986e461dc072 Initial revision
glantau
parents:
diff changeset
4695 s->qscale = get_bits(&s->gb, 5);
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
4696 skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4697
986e461dc072 Initial revision
glantau
parents:
diff changeset
4698 /* PEI */
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
4699 while (get_bits1(&s->gb) != 0) {
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
4700 skip_bits(&s->gb, 8);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4701 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
4702 s->f_code = 1;
770
d1770a34e4f6 segfault fix patch by (Juergen Keil <jk at tools dot de>)
michaelni
parents: 766
diff changeset
4703
d1770a34e4f6 segfault fix patch by (Juergen Keil <jk at tools dot de>)
michaelni
parents: 766
diff changeset
4704 s->y_dc_scale_table=
d1770a34e4f6 segfault fix patch by (Juergen Keil <jk at tools dot de>)
michaelni
parents: 766
diff changeset
4705 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
4706
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4707 return 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
4708 }
144
cb5dabd00ba2 - Bug fix on inter MCBPC table for inter+q.
pulento
parents: 110
diff changeset
4709