annotate h263.c @ 1034:af7ba8d8b43a libavcodec

feeding doxygen
author michaelni
date Sun, 26 Jan 2003 23:09:12 +0000
parents 1f9afd8b9131
children a78f6f72d54e
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 */
1034
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
25
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
26 /**
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
27 * @file h263.c
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
28 * @brief h263/mpeg4 codec
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
29 *
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
30 */
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
31
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
32 //#define DEBUG
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
33 #include "common.h"
986e461dc072 Initial revision
glantau
parents:
diff changeset
34 #include "dsputil.h"
986e461dc072 Initial revision
glantau
parents:
diff changeset
35 #include "avcodec.h"
986e461dc072 Initial revision
glantau
parents:
diff changeset
36 #include "mpegvideo.h"
986e461dc072 Initial revision
glantau
parents:
diff changeset
37 #include "h263data.h"
986e461dc072 Initial revision
glantau
parents:
diff changeset
38 #include "mpeg4data.h"
986e461dc072 Initial revision
glantau
parents:
diff changeset
39
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
40 //#undef NDEBUG
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
41 //#include <assert.h>
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
42
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
43 #if 1
523
c7e4c8b9a3c4 warning fix patch by atmos
michaelni
parents: 498
diff changeset
44 #define PRINT_MB_TYPE(a) {}
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
45 #else
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
46 #define PRINT_MB_TYPE(a) printf(a)
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
47 #endif
359
df0736462b9f move ABS() to common.h
michaelni
parents: 358
diff changeset
48
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
49 #define INTRA_MCBPC_VLC_BITS 6
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
50 #define INTER_MCBPC_VLC_BITS 6
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
51 #define CBPY_VLC_BITS 6
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
52 #define MV_VLC_BITS 9
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
53 #define DC_VLC_BITS 9
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
54 #define SPRITE_TRAJ_VLC_BITS 6
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
55 #define MB_TYPE_B_VLC_BITS 4
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
56 #define TEX_VLC_BITS 9
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
57
815
78accc54493b put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents: 770
diff changeset
58 #ifdef CONFIG_ENCODERS
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
59 static void h263_encode_block(MpegEncContext * s, DCTELEM * block,
986e461dc072 Initial revision
glantau
parents:
diff changeset
60 int n);
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
61 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
62 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
63 static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block,
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
64 int n, int dc, UINT8 *scan_table,
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
65 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
66 #endif
78accc54493b put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents: 770
diff changeset
67
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
68 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
69 static int h263p_decode_umotion(MpegEncContext * s, int pred);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
70 static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
986e461dc072 Initial revision
glantau
parents:
diff changeset
71 int n, int coded);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
72 static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
73 static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
74 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
75 static int h263_pred_dc(MpegEncContext * s, int n, UINT16 **dc_val_ptr);
1008
fb6cbb8a04a3 fixing DCTELEM != short
michaelni
parents: 999
diff changeset
76 static void mpeg4_inv_pred_ac(MpegEncContext * s, DCTELEM *block, int n,
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
77 int dir);
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
78 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
79 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
80
277
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
81 extern UINT32 inverse[256];
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
82
1013
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1008
diff changeset
83 static UINT8 uni_DCtab_lum_len[512];
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1008
diff changeset
84 static UINT8 uni_DCtab_chrom_len[512];
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1008
diff changeset
85 static UINT16 uni_DCtab_lum_bits[512];
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1008
diff changeset
86 static UINT16 uni_DCtab_chrom_bits[512];
815
78accc54493b put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents: 770
diff changeset
87
78accc54493b put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents: 770
diff changeset
88 #ifdef CONFIG_ENCODERS
78accc54493b put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents: 770
diff changeset
89 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
90 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
91 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
92
945
463f7260b155 trellis quantization
michaelni
parents: 942
diff changeset
93 static uint32_t uni_mpeg4_intra_rl_bits[64*64*2*2];
463f7260b155 trellis quantization
michaelni
parents: 942
diff changeset
94 static uint8_t uni_mpeg4_intra_rl_len [64*64*2*2];
463f7260b155 trellis quantization
michaelni
parents: 942
diff changeset
95 static uint32_t uni_mpeg4_inter_rl_bits[64*64*2*2];
463f7260b155 trellis quantization
michaelni
parents: 942
diff changeset
96 static uint8_t uni_mpeg4_inter_rl_len [64*64*2*2];
463f7260b155 trellis quantization
michaelni
parents: 942
diff changeset
97 //#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128 + (run)*256 + (level))
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
98 //#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run) + (level)*64)
945
463f7260b155 trellis quantization
michaelni
parents: 942
diff changeset
99 #define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run)*128 + (level))
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
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
101 /* 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
102 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
103 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
104 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
105
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
106 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
107 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
108 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
109 */
815
78accc54493b put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents: 770
diff changeset
110 #endif
78accc54493b put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents: 770
diff changeset
111
293
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
112
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
113 int h263_get_picture_format(int width, int height)
986e461dc072 Initial revision
glantau
parents:
diff changeset
114 {
986e461dc072 Initial revision
glantau
parents:
diff changeset
115 int format;
986e461dc072 Initial revision
glantau
parents:
diff changeset
116
986e461dc072 Initial revision
glantau
parents:
diff changeset
117 if (width == 128 && height == 96)
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
118 format = 1;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
119 else if (width == 176 && height == 144)
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
120 format = 2;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
121 else if (width == 352 && height == 288)
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
122 format = 3;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
123 else if (width == 704 && height == 576)
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
124 format = 4;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
125 else if (width == 1408 && height == 1152)
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
126 format = 5;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
127 else
986e461dc072 Initial revision
glantau
parents:
diff changeset
128 format = 7;
986e461dc072 Initial revision
glantau
parents:
diff changeset
129 return format;
986e461dc072 Initial revision
glantau
parents:
diff changeset
130 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
131
887
19f5b8b7c6d5 fixing aspect
michaelni
parents: 880
diff changeset
132 static void float_aspect_to_info(MpegEncContext * s, float aspect){
19f5b8b7c6d5 fixing aspect
michaelni
parents: 880
diff changeset
133 int i;
19f5b8b7c6d5 fixing aspect
michaelni
parents: 880
diff changeset
134
19f5b8b7c6d5 fixing aspect
michaelni
parents: 880
diff changeset
135 aspect*= s->height/(double)s->width;
19f5b8b7c6d5 fixing aspect
michaelni
parents: 880
diff changeset
136 //printf("%f\n", aspect);
880
1c32039e7215 aspect ratio cleanup
michaelni
parents: 853
diff changeset
137
887
19f5b8b7c6d5 fixing aspect
michaelni
parents: 880
diff changeset
138 if(aspect==0) aspect= 1.0;
19f5b8b7c6d5 fixing aspect
michaelni
parents: 880
diff changeset
139
880
1c32039e7215 aspect ratio cleanup
michaelni
parents: 853
diff changeset
140 ff_float2fraction(&s->aspected_width, &s->aspected_height, aspect, 255);
887
19f5b8b7c6d5 fixing aspect
michaelni
parents: 880
diff changeset
141
19f5b8b7c6d5 fixing aspect
michaelni
parents: 880
diff changeset
142 //printf("%d %d\n", s->aspected_width, s->aspected_height);
19f5b8b7c6d5 fixing aspect
michaelni
parents: 880
diff changeset
143 for(i=1; i<6; i++){
19f5b8b7c6d5 fixing aspect
michaelni
parents: 880
diff changeset
144 if(s->aspected_width == pixel_aspect[i][0] && s->aspected_height== pixel_aspect[i][1]){
19f5b8b7c6d5 fixing aspect
michaelni
parents: 880
diff changeset
145 s->aspect_ratio_info=i;
19f5b8b7c6d5 fixing aspect
michaelni
parents: 880
diff changeset
146 return;
19f5b8b7c6d5 fixing aspect
michaelni
parents: 880
diff changeset
147 }
19f5b8b7c6d5 fixing aspect
michaelni
parents: 880
diff changeset
148 }
880
1c32039e7215 aspect ratio cleanup
michaelni
parents: 853
diff changeset
149
887
19f5b8b7c6d5 fixing aspect
michaelni
parents: 880
diff changeset
150 s->aspect_ratio_info= FF_ASPECT_EXTENDED;
880
1c32039e7215 aspect ratio cleanup
michaelni
parents: 853
diff changeset
151 }
1c32039e7215 aspect ratio cleanup
michaelni
parents: 853
diff changeset
152
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
153 void h263_encode_picture_header(MpegEncContext * s, int picture_number)
986e461dc072 Initial revision
glantau
parents:
diff changeset
154 {
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
155 int format;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
156
986e461dc072 Initial revision
glantau
parents:
diff changeset
157 align_put_bits(&s->pb);
231
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
158
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
159 /* 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
160 s->ptr_lastgob = pbBufPtr(&s->pb);
231
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
161 s->gob_number = 0;
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
162
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
163 put_bits(&s->pb, 22, 0x20); /* PSC */
241
4bb6289eff93 avoid overflow of picturenumber*fps*10000
michaelni
parents: 234
diff changeset
164 put_bits(&s->pb, 8, (((INT64)s->picture_number * 30 * FRAME_RATE_BASE) /
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
165 s->frame_rate) & 0xff);
986e461dc072 Initial revision
glantau
parents:
diff changeset
166
986e461dc072 Initial revision
glantau
parents:
diff changeset
167 put_bits(&s->pb, 1, 1); /* marker */
986e461dc072 Initial revision
glantau
parents:
diff changeset
168 put_bits(&s->pb, 1, 0); /* h263 id */
986e461dc072 Initial revision
glantau
parents:
diff changeset
169 put_bits(&s->pb, 1, 0); /* split screen off */
986e461dc072 Initial revision
glantau
parents:
diff changeset
170 put_bits(&s->pb, 1, 0); /* camera off */
986e461dc072 Initial revision
glantau
parents:
diff changeset
171 put_bits(&s->pb, 1, 0); /* freeze picture release off */
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
172
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
173 format = h263_get_picture_format(s->width, s->height);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
174 if (!s->h263_plus) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
175 /* H.263v1 */
986e461dc072 Initial revision
glantau
parents:
diff changeset
176 put_bits(&s->pb, 3, format);
986e461dc072 Initial revision
glantau
parents:
diff changeset
177 put_bits(&s->pb, 1, (s->pict_type == P_TYPE));
986e461dc072 Initial revision
glantau
parents:
diff changeset
178 /* By now UMV IS DISABLED ON H.263v1, since the restrictions
986e461dc072 Initial revision
glantau
parents:
diff changeset
179 of H.263v1 UMV implies to check the predicted MV after
986e461dc072 Initial revision
glantau
parents:
diff changeset
180 calculation of the current MB to see if we're on the limits */
986e461dc072 Initial revision
glantau
parents:
diff changeset
181 put_bits(&s->pb, 1, 0); /* unrestricted motion vector: off */
986e461dc072 Initial revision
glantau
parents:
diff changeset
182 put_bits(&s->pb, 1, 0); /* SAC: off */
986e461dc072 Initial revision
glantau
parents:
diff changeset
183 put_bits(&s->pb, 1, 0); /* advanced prediction mode: off */
986e461dc072 Initial revision
glantau
parents:
diff changeset
184 put_bits(&s->pb, 1, 0); /* not PB frame */
986e461dc072 Initial revision
glantau
parents:
diff changeset
185 put_bits(&s->pb, 5, s->qscale);
986e461dc072 Initial revision
glantau
parents:
diff changeset
186 put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */
986e461dc072 Initial revision
glantau
parents:
diff changeset
187 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
188 /* H.263v2 */
986e461dc072 Initial revision
glantau
parents:
diff changeset
189 /* H.263 Plus PTYPE */
986e461dc072 Initial revision
glantau
parents:
diff changeset
190 put_bits(&s->pb, 3, 7);
986e461dc072 Initial revision
glantau
parents:
diff changeset
191 put_bits(&s->pb,3,1); /* Update Full Extended PTYPE */
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
192 if (format == 7)
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
193 put_bits(&s->pb,3,6); /* Custom Source Format */
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
194 else
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
195 put_bits(&s->pb, 3, format);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
196
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
197 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
198 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
199 put_bits(&s->pb, 1, s->umvplus); /* Unrestricted Motion Vector */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
200 put_bits(&s->pb,1,0); /* SAC: off */
986e461dc072 Initial revision
glantau
parents:
diff changeset
201 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
202 put_bits(&s->pb,1,s->h263_aic); /* Advanced Intra Coding */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
203 put_bits(&s->pb,1,0); /* Deblocking Filter: off */
986e461dc072 Initial revision
glantau
parents:
diff changeset
204 put_bits(&s->pb,1,0); /* Slice Structured: off */
986e461dc072 Initial revision
glantau
parents:
diff changeset
205 put_bits(&s->pb,1,0); /* Reference Picture Selection: off */
986e461dc072 Initial revision
glantau
parents:
diff changeset
206 put_bits(&s->pb,1,0); /* Independent Segment Decoding: off */
986e461dc072 Initial revision
glantau
parents:
diff changeset
207 put_bits(&s->pb,1,0); /* Alternative Inter VLC: off */
986e461dc072 Initial revision
glantau
parents:
diff changeset
208 put_bits(&s->pb,1,0); /* Modified Quantization: off */
986e461dc072 Initial revision
glantau
parents:
diff changeset
209 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
986e461dc072 Initial revision
glantau
parents:
diff changeset
210 put_bits(&s->pb,3,0); /* Reserved */
986e461dc072 Initial revision
glantau
parents:
diff changeset
211
986e461dc072 Initial revision
glantau
parents:
diff changeset
212 put_bits(&s->pb, 3, s->pict_type == P_TYPE);
986e461dc072 Initial revision
glantau
parents:
diff changeset
213
986e461dc072 Initial revision
glantau
parents:
diff changeset
214 put_bits(&s->pb,1,0); /* Reference Picture Resampling: off */
986e461dc072 Initial revision
glantau
parents:
diff changeset
215 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
216 put_bits(&s->pb,1,s->no_rounding); /* Rounding Type */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
217 put_bits(&s->pb,2,0); /* Reserved */
986e461dc072 Initial revision
glantau
parents:
diff changeset
218 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
986e461dc072 Initial revision
glantau
parents:
diff changeset
219
986e461dc072 Initial revision
glantau
parents:
diff changeset
220 /* This should be here if PLUSPTYPE */
986e461dc072 Initial revision
glantau
parents:
diff changeset
221 put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */
986e461dc072 Initial revision
glantau
parents:
diff changeset
222
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
223 if (format == 7) {
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
224 /* Custom Picture Format (CPFMT) */
887
19f5b8b7c6d5 fixing aspect
michaelni
parents: 880
diff changeset
225 float_aspect_to_info(s, s->avctx->aspect_ratio);
880
1c32039e7215 aspect ratio cleanup
michaelni
parents: 853
diff changeset
226
1c32039e7215 aspect ratio cleanup
michaelni
parents: 853
diff changeset
227 put_bits(&s->pb,4,s->aspect_ratio_info);
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
228 put_bits(&s->pb,9,(s->width >> 2) - 1);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
229 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
230 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
231 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
232 {
b4bddbde44f3 aspect (ext. par too) support for h263 and mpeg4 (inc. build becouse of new vars)
al3x
parents: 667
diff changeset
233 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
234 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
235 }
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
236 }
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
237
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
238 /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
79
82e579c37bc3 Moved some H.263+ variables to MpegEncContext to be thread-safe.
pulento
parents: 78
diff changeset
239 if (s->umvplus)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
240 put_bits(&s->pb,1,1); /* Limited according tables of Annex D */
986e461dc072 Initial revision
glantau
parents:
diff changeset
241 put_bits(&s->pb, 5, s->qscale);
986e461dc072 Initial revision
glantau
parents:
diff changeset
242 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
243
986e461dc072 Initial revision
glantau
parents:
diff changeset
244 put_bits(&s->pb, 1, 0); /* no PEI */
498
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
245
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
246 if(s->h263_aic){
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
247 s->y_dc_scale_table=
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
248 s->c_dc_scale_table= h263_aic_dc_scale_table;
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
249 }else{
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
250 s->y_dc_scale_table=
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
251 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
252 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
253 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
254
766
8d36b35a7e6e slice encoding cleanup
michaelni
parents: 761
diff changeset
255 /**
8d36b35a7e6e slice encoding cleanup
michaelni
parents: 761
diff changeset
256 * Encodes a group of blocks header.
8d36b35a7e6e slice encoding cleanup
michaelni
parents: 761
diff changeset
257 */
162
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
258 int h263_encode_gob_header(MpegEncContext * s, int mb_line)
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
259 {
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
260 align_put_bits(&s->pb);
231
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
261 flush_put_bits(&s->pb);
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
262 /* Call the RTP callback to send the last GOB */
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
263 if (s->rtp_callback) {
766
8d36b35a7e6e slice encoding cleanup
michaelni
parents: 761
diff changeset
264 int pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;
231
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
265 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
266 }
162
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
267 put_bits(&s->pb, 17, 1); /* GBSC */
231
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
268 s->gob_number = mb_line / s->gob_index;
162
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
269 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
270 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
271 put_bits(&s->pb, 5, s->qscale); /* GQUANT */
231
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
272 //fprintf(stderr,"\nGOB: %2d size: %d", s->gob_number - 1, pdif);
766
8d36b35a7e6e slice encoding cleanup
michaelni
parents: 761
diff changeset
273 return 0;
162
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
274 }
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
275
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
276 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
277 {
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
278 int score0=0, score1=0;
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
279 int i, n;
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
280 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
281
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
282 for(n=0; n<6; n++){
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
283 INT16 *ac_val, *ac_val1;
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
284
266
252444e5259b optimization
michaelni
parents: 265
diff changeset
285 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
286 ac_val1= ac_val;
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
287 if(dir[n]){
692
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
288 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
289 /* top prediction */
266
252444e5259b optimization
michaelni
parents: 265
diff changeset
290 ac_val-= s->block_wrap[n]*16;
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
291 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
292 /* same qscale */
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
293 for(i=1; i<8; i++){
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
294 const int level= block[n][s->idct_permutation[i ]];
692
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
295 score0+= ABS(level);
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
296 score1+= ABS(level - ac_val[i+8]);
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
297 ac_val1[i ]= block[n][s->idct_permutation[i<<3]];
692
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
298 ac_val1[i+8]= level;
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
299 }
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
300 }else{
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
301 /* different qscale, we must rescale */
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
302 for(i=1; i<8; i++){
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
303 const int level= block[n][s->idct_permutation[i ]];
692
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
304 score0+= ABS(level);
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
305 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
306 ac_val1[i ]= block[n][s->idct_permutation[i<<3]];
692
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
307 ac_val1[i+8]= level;
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
308 }
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
309 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
310 }else{
692
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
311 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
312 /* left prediction */
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
313 ac_val-= 16;
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
314 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
315 /* same qscale */
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
316 for(i=1; i<8; i++){
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
317 const int level= block[n][s->idct_permutation[i<<3]];
692
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
318 score0+= ABS(level);
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
319 score1+= ABS(level - ac_val[i]);
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
320 ac_val1[i ]= level;
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
321 ac_val1[i+8]= block[n][s->idct_permutation[i ]];
692
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
322 }
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
323 }else{
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
324 /* different qscale, we must rescale */
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
325 for(i=1; i<8; i++){
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
326 const int level= block[n][s->idct_permutation[i<<3]];
692
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
327 score0+= ABS(level);
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
328 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
329 ac_val1[i ]= level;
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
330 ac_val1[i+8]= block[n][s->idct_permutation[i ]];
692
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
331 }
265
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 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
334 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
335
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
336 return score0 > score1 ? 1 : 0;
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
337 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
338
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
339 /**
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
340 * 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
341 */
695
3525da287ee2 adaptive quantization for h263
michaelni
parents: 692
diff changeset
342 void ff_clean_h263_qscales(MpegEncContext *s){
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
343 int i;
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
344 int8_t * const qscale_table= s->current_picture.qscale_table;
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
345
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
346 for(i=1; i<s->mb_num; i++){
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
347 if(qscale_table[i] - qscale_table[i-1] >2)
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
348 qscale_table[i]= qscale_table[i-1]+2;
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
349 }
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
350 for(i=s->mb_num-2; i>=0; i--){
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
351 if(qscale_table[i] - qscale_table[i+1] >2)
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
352 qscale_table[i]= qscale_table[i+1]+2;
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
353 }
695
3525da287ee2 adaptive quantization for h263
michaelni
parents: 692
diff changeset
354 }
3525da287ee2 adaptive quantization for h263
michaelni
parents: 692
diff changeset
355
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
356 /**
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
357 * 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
358 */
695
3525da287ee2 adaptive quantization for h263
michaelni
parents: 692
diff changeset
359 void ff_clean_mpeg4_qscales(MpegEncContext *s){
3525da287ee2 adaptive quantization for h263
michaelni
parents: 692
diff changeset
360 int i;
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
361 int8_t * const qscale_table= s->current_picture.qscale_table;
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
362
695
3525da287ee2 adaptive quantization for h263
michaelni
parents: 692
diff changeset
363 ff_clean_h263_qscales(s);
690
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 for(i=1; i<s->mb_num; i++){
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
366 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
367 s->mb_type[i]&= ~MB_TYPE_INTER4V;
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
368 s->mb_type[i]|= MB_TYPE_INTER;
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
369 }
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
370 }
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
371
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
372 if(s->pict_type== B_TYPE){
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
373 int odd=0;
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
374 /* 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
375 for the actual adaptive quantization */
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
376
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
377 for(i=0; i<s->mb_num; i++){
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
378 odd += qscale_table[i]&1;
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
379 }
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
380
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
381 if(2*odd > s->mb_num) odd=1;
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
382 else odd=0;
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
383
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
384 for(i=0; i<s->mb_num; i++){
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
385 if((qscale_table[i]&1) != odd)
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
386 qscale_table[i]++;
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
387 if(qscale_table[i] > 31)
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
388 qscale_table[i]= 31;
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
389 }
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 for(i=1; i<s->mb_num; i++){
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
392 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
393 s->mb_type[i]&= ~MB_TYPE_DIRECT;
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
394 s->mb_type[i]|= MB_TYPE_BIDIR;
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
395 }
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
396 }
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
397 }
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
398 }
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
399
936
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
400 void ff_mpeg4_set_direct_mv(MpegEncContext *s, int mx, int my){
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
401 const int mb_index= s->mb_x + s->mb_y*s->mb_width;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
402 int xy= s->block_index[0];
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
403 uint16_t time_pp= s->pp_time;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
404 uint16_t time_pb= s->pb_time;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
405 int i;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
406
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
407 //FIXME avoid divides
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
408 switch(s->co_located_type_table[mb_index]){
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
409 case 0:
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
410 s->mv_type= MV_TYPE_16X16;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
411 s->mv[0][0][0] = s->motion_val[xy][0]*time_pb/time_pp + mx;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
412 s->mv[0][0][1] = s->motion_val[xy][1]*time_pb/time_pp + my;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
413 s->mv[1][0][0] = mx ? s->mv[0][0][0] - s->motion_val[xy][0]
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
414 : s->motion_val[xy][0]*(time_pb - time_pp)/time_pp;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
415 s->mv[1][0][1] = my ? s->mv[0][0][1] - s->motion_val[xy][1]
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
416 : s->motion_val[xy][1]*(time_pb - time_pp)/time_pp;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
417 break;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
418 case CO_LOCATED_TYPE_4MV:
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
419 s->mv_type = MV_TYPE_8X8;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
420 for(i=0; i<4; i++){
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
421 xy= s->block_index[i];
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
422 s->mv[0][i][0] = s->motion_val[xy][0]*time_pb/time_pp + mx;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
423 s->mv[0][i][1] = s->motion_val[xy][1]*time_pb/time_pp + my;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
424 s->mv[1][i][0] = mx ? s->mv[0][i][0] - s->motion_val[xy][0]
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
425 : s->motion_val[xy][0]*(time_pb - time_pp)/time_pp;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
426 s->mv[1][i][1] = my ? s->mv[0][i][1] - s->motion_val[xy][1]
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
427 : s->motion_val[xy][1]*(time_pb - time_pp)/time_pp;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
428 }
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
429 break;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
430 case CO_LOCATED_TYPE_FIELDMV:
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
431 s->mv_type = MV_TYPE_FIELD;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
432 for(i=0; i<2; i++){
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
433 if(s->top_field_first){
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
434 time_pp= s->pp_field_time - s->field_select_table[mb_index][i] + i;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
435 time_pb= s->pb_field_time - s->field_select_table[mb_index][i] + i;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
436 }else{
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
437 time_pp= s->pp_field_time + s->field_select_table[mb_index][i] - i;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
438 time_pb= s->pb_field_time + s->field_select_table[mb_index][i] - i;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
439 }
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
440 s->mv[0][i][0] = s->field_mv_table[mb_index][i][0]*time_pb/time_pp + mx;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
441 s->mv[0][i][1] = s->field_mv_table[mb_index][i][1]*time_pb/time_pp + my;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
442 s->mv[1][i][0] = mx ? s->mv[0][i][0] - s->field_mv_table[mb_index][i][0]
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
443 : s->field_mv_table[mb_index][i][0]*(time_pb - time_pp)/time_pp;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
444 s->mv[1][i][1] = my ? s->mv[0][i][1] - s->field_mv_table[mb_index][i][1]
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
445 : s->field_mv_table[mb_index][i][1]*(time_pb - time_pp)/time_pp;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
446 }
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
447 break;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
448 }
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
449 }
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
450
815
78accc54493b put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents: 770
diff changeset
451 #ifdef CONFIG_ENCODERS
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
452 void mpeg4_encode_mb(MpegEncContext * s,
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
453 DCTELEM block[6][64],
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
454 int motion_x, int motion_y)
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
455 {
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
456 int cbpc, cbpy, i, pred_x, pred_y;
286
91f7c38f5f37 statistics for 2-pass encoding
michaelni
parents: 285
diff changeset
457 int bits;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
458 PutBitContext * const pb2 = s->data_partitioning ? &s->pb2 : &s->pb;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
459 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
460 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
461 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
462 const int dquant_code[5]= {1,0,9,2,3};
162
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
463
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
464 // 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
465 if (!s->mb_intra) {
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
466 /* compute cbp */
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
467 int cbp = 0;
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
468 for (i = 0; i < 6; i++) {
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
469 if (s->block_last_index[i] >= 0)
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
470 cbp |= 1 << (5 - i);
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
471 }
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
472
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
473 if(s->pict_type==B_TYPE){
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
474 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
475 int mb_type= mb_type_table[s->mv_dir];
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
476
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
477 if(s->mb_x==0){
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
478 s->last_mv[0][0][0]=
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
479 s->last_mv[0][0][1]=
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
480 s->last_mv[1][0][0]=
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
481 s->last_mv[1][0][1]= 0;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
482 }
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
483
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
484 assert(s->dquant>=-2 && s->dquant<=2);
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
485 assert((s->dquant&1)==0);
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
486 assert(mb_type>=0);
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
487
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
488 /* nothing to do if this MB was skiped in the next P Frame */
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
489 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
490 s->skip_count++;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
491 s->mv[0][0][0]=
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
492 s->mv[0][0][1]=
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
493 s->mv[1][0][0]=
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
494 s->mv[1][0][1]= 0;
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
495 s->mv_dir= MV_DIR_FORWARD; //doesnt matter
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
496 s->qscale -= s->dquant;
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
497 // s->mb_skiped=1;
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
498
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
499 return;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
500 }
936
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
501
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
502 if ((cbp | motion_x | motion_y | mb_type) ==0) {
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
503 /* direct MB with MV={0,0} */
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
504 assert(s->dquant==0);
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
505
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
506 put_bits(&s->pb, 1, 1); /* mb not coded modb1=1 */
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
507
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
508 if(interleaved_stats){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
509 s->misc_bits++;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
510 s->last_bits++;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
511 }
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
512 s->skip_count++;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
513 return;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
514 }
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
515
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
516 put_bits(&s->pb, 1, 0); /* mb coded modb1=0 */
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
517 put_bits(&s->pb, 1, cbp ? 0 : 1); /* modb2 */ //FIXME merge
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
518 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
519 if(cbp) put_bits(&s->pb, 6, cbp);
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
520
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
521 if(cbp && mb_type){
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
522 if(s->dquant)
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
523 put_bits(&s->pb, 2, (s->dquant>>2)+3);
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
524 else
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
525 put_bits(&s->pb, 1, 0);
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
526 }else
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
527 s->qscale -= s->dquant;
697
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
528
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
529 if(!s->progressive_sequence){
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
530 if(cbp)
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
531 put_bits(&s->pb, 1, s->interlaced_dct);
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
532 if(mb_type) // not diect mode
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
533 put_bits(&s->pb, 1, 0); // no interlaced ME yet
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
534 }
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
535
453
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->misc_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 }
295
6622b0fd036c mpeg4 4MV encoding
michaelni
parents: 294
diff changeset
541
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
542 switch(mb_type)
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
543 {
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
544 case 0: /* direct */
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
545 h263_encode_motion(s, motion_x, 1);
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
546 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
547 s->b_count++;
e47fa3e3f2d5 statistics for forw & back p-MBs instead of just one counter for both
michaelni
parents: 654
diff changeset
548 s->f_count++;
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
549 break;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
550 case 1: /* bidir */
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
551 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
552 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
553 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
554 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
555 s->last_mv[0][0][0]= s->mv[0][0][0];
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
556 s->last_mv[0][0][1]= s->mv[0][0][1];
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
557 s->last_mv[1][0][0]= s->mv[1][0][0];
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
558 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
559 s->b_count++;
e47fa3e3f2d5 statistics for forw & back p-MBs instead of just one counter for both
michaelni
parents: 654
diff changeset
560 s->f_count++;
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
561 break;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
562 case 2: /* backward */
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
563 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
564 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
565 s->last_mv[1][0][0]= motion_x;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
566 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
567 s->b_count++;
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
568 break;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
569 case 3: /* forward */
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
570 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
571 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
572 s->last_mv[0][0][0]= motion_x;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
573 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
574 s->f_count++;
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
575 break;
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
576 default:
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
577 printf("unknown mb type\n");
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
578 return;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
579 }
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
580
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
581 if(interleaved_stats){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
582 bits= get_bit_count(&s->pb);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
583 s->mv_bits+= bits - s->last_bits;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
584 s->last_bits=bits;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
585 }
295
6622b0fd036c mpeg4 4MV encoding
michaelni
parents: 294
diff changeset
586
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
587 /* encode each block */
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
588 for (i = 0; i < 6; i++) {
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
589 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
590 }
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
591
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
592 if(interleaved_stats){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
593 bits= get_bit_count(&s->pb);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
594 s->p_tex_bits+= bits - s->last_bits;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
595 s->last_bits=bits;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
596 }
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
597 }else{ /* s->pict_type==B_TYPE */
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
598 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
599 /* 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
600 why didnt they just compress the skip-mb bits instead of reusing them ?! */
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
601 if(s->max_b_frames>0){
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
602 int i;
364
6b6332e7008a segfault fix for b-frame encoding with height%16!=0
michaelni
parents: 360
diff changeset
603 int x,y, offset;
6b6332e7008a segfault fix for b-frame encoding with height%16!=0
michaelni
parents: 360
diff changeset
604 uint8_t *p_pic;
6b6332e7008a segfault fix for b-frame encoding with height%16!=0
michaelni
parents: 360
diff changeset
605
6b6332e7008a segfault fix for b-frame encoding with height%16!=0
michaelni
parents: 360
diff changeset
606 x= s->mb_x*16;
6b6332e7008a segfault fix for b-frame encoding with height%16!=0
michaelni
parents: 360
diff changeset
607 y= s->mb_y*16;
6b6332e7008a segfault fix for b-frame encoding with height%16!=0
michaelni
parents: 360
diff changeset
608 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
609 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
610
6b6332e7008a segfault fix for b-frame encoding with height%16!=0
michaelni
parents: 360
diff changeset
611 offset= x + y*s->linesize;
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
612 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
613
331
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
614 s->mb_skiped=1;
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
615 for(i=0; i<s->max_b_frames; i++){
339
b743a6bbab25 segfault fix
michaelni
parents: 336
diff changeset
616 uint8_t *b_pic;
b743a6bbab25 segfault fix
michaelni
parents: 336
diff changeset
617 int diff;
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
618 Picture *pic= s->reordered_input_picture[i+1];
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
619
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
620 if(pic==NULL || pic->pict_type!=B_TYPE) break;
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
621
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
622 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
623 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
624 if(diff>s->qscale*70){ //FIXME check that 70 is optimal
331
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
625 s->mb_skiped=0;
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
626 break;
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
627 }
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
628 }
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
629 }else
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
630 s->mb_skiped=1;
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
631
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
632 if(s->mb_skiped==1){
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
633 /* skip macroblock */
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
634 put_bits(&s->pb, 1, 1);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
635
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
636 if(interleaved_stats){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
637 s->misc_bits++;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
638 s->last_bits++;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
639 }
331
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
640 s->skip_count++;
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
641 return;
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
642 }
295
6622b0fd036c mpeg4 4MV encoding
michaelni
parents: 294
diff changeset
643 }
364
6b6332e7008a segfault fix for b-frame encoding with height%16!=0
michaelni
parents: 360
diff changeset
644
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
645 put_bits(&s->pb, 1, 0); /* mb coded */
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
646 if(s->mv_type==MV_TYPE_16X16){
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
647 cbpc = cbp & 3;
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
648 if(s->dquant) cbpc+= 8;
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
649 put_bits(&s->pb,
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
650 inter_MCBPC_bits[cbpc],
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
651 inter_MCBPC_code[cbpc]);
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
652
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
653 cbpy = cbp >> 2;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
654 cbpy ^= 0xf;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
655 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
656 if(s->dquant)
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
657 put_bits(pb2, 2, dquant_code[s->dquant+2]);
697
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
658
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
659 if(!s->progressive_sequence){
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
660 if(cbp)
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
661 put_bits(pb2, 1, s->interlaced_dct);
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
662 put_bits(pb2, 1, 0); // no interlaced ME yet
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
663 }
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
664
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
665 if(interleaved_stats){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
666 bits= get_bit_count(&s->pb);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
667 s->misc_bits+= bits - s->last_bits;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
668 s->last_bits=bits;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
669 }
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
670
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
671 /* motion vectors: 16x16 mode */
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
672 h263_pred_motion(s, 0, &pred_x, &pred_y);
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
673
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
674 h263_encode_motion(s, motion_x - pred_x, s->f_code);
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
675 h263_encode_motion(s, motion_y - pred_y, s->f_code);
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
676 }else{
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
677 cbpc = (cbp & 3)+16;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
678 put_bits(&s->pb,
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
679 inter_MCBPC_bits[cbpc],
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
680 inter_MCBPC_code[cbpc]);
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
681 cbpy = cbp >> 2;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
682 cbpy ^= 0xf;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
683 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
684
757
d031d1575ceb fixing interlaced dct with 4mv
michaelni
parents: 753
diff changeset
685 if(!s->progressive_sequence){
d031d1575ceb fixing interlaced dct with 4mv
michaelni
parents: 753
diff changeset
686 if(cbp)
d031d1575ceb fixing interlaced dct with 4mv
michaelni
parents: 753
diff changeset
687 put_bits(pb2, 1, s->interlaced_dct);
d031d1575ceb fixing interlaced dct with 4mv
michaelni
parents: 753
diff changeset
688 }
d031d1575ceb fixing interlaced dct with 4mv
michaelni
parents: 753
diff changeset
689
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
690 if(interleaved_stats){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
691 bits= get_bit_count(&s->pb);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
692 s->misc_bits+= bits - s->last_bits;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
693 s->last_bits=bits;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
694 }
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
695
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
696 for(i=0; i<4; i++){
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
697 /* motion vectors: 8x8 mode*/
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
698 h263_pred_motion(s, i, &pred_x, &pred_y);
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
699
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
700 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
701 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
702 }
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
703 }
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
704
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
705 if(interleaved_stats){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
706 bits= get_bit_count(&s->pb);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
707 s->mv_bits+= bits - s->last_bits;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
708 s->last_bits=bits;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
709 }
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
710
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
711 /* encode each block */
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
712 for (i = 0; i < 6; i++) {
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
713 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
714 }
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
715
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
716 if(interleaved_stats){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
717 bits= get_bit_count(&s->pb);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
718 s->p_tex_bits+= bits - s->last_bits;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
719 s->last_bits=bits;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
720 }
656
e47fa3e3f2d5 statistics for forw & back p-MBs instead of just one counter for both
michaelni
parents: 654
diff changeset
721 s->f_count++;
295
6622b0fd036c mpeg4 4MV encoding
michaelni
parents: 294
diff changeset
722 }
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
723 } else {
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
724 int cbp;
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
725 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
726 int dir[6]; //prediction direction
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
727 int zigzag_last_index[6];
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
728 UINT8 *scan_table[6];
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
729
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
730 for(i=0; i<6; i++){
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
731 const int level= block[i][0];
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
732 UINT16 *dc_ptr;
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
733
498
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
734 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
735 if (i < 4) {
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
736 *dc_ptr = level * s->y_dc_scale;
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
737 } else {
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
738 *dc_ptr = level * s->c_dc_scale;
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
739 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
740 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
741
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
742 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
743
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
744 if(s->ac_pred){
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
745 for(i=0; i<6; i++){
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
746 UINT8 *st;
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
747 int last_index;
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
748
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
749 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
750 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
751 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
752
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
753 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
754 if(block[i][st[last_index]]) break;
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
755 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
756 s->block_last_index[i]= last_index;
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
757 scan_table[i]= st;
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
758 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
759 }else{
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
760 for(i=0; i<6; i++)
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
761 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
762 }
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 /* compute cbp */
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
765 cbp = 0;
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
766 for (i = 0; i < 6; i++) {
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
767 if (s->block_last_index[i] >= 1)
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
768 cbp |= 1 << (5 - i);
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
769 }
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 cbpc = cbp & 3;
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
772 if (s->pict_type == I_TYPE) {
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
773 if(s->dquant) cbpc+=4;
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
774 put_bits(&s->pb,
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
775 intra_MCBPC_bits[cbpc],
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
776 intra_MCBPC_code[cbpc]);
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
777 } else {
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
778 if(s->dquant) cbpc+=8;
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
779 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
780 put_bits(&s->pb,
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
781 inter_MCBPC_bits[cbpc + 4],
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
782 inter_MCBPC_code[cbpc + 4]);
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
783 }
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
784 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
785 cbpy = cbp >> 2;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
786 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
787 if(s->dquant)
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
788 put_bits(dc_pb, 2, dquant_code[s->dquant+2]);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
789
697
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
790 if(!s->progressive_sequence){
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
791 put_bits(dc_pb, 1, s->interlaced_dct);
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
792 }
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
793
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
794 if(interleaved_stats){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
795 bits= get_bit_count(&s->pb);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
796 s->misc_bits+= bits - s->last_bits;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
797 s->last_bits=bits;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
798 }
286
91f7c38f5f37 statistics for 2-pass encoding
michaelni
parents: 285
diff changeset
799
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
800 /* encode each block */
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
801 for (i = 0; i < 6; i++) {
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
802 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
803 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
804
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
805 if(interleaved_stats){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
806 bits= get_bit_count(&s->pb);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
807 s->i_tex_bits+= bits - s->last_bits;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
808 s->last_bits=bits;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
809 }
286
91f7c38f5f37 statistics for 2-pass encoding
michaelni
parents: 285
diff changeset
810 s->i_count++;
91f7c38f5f37 statistics for 2-pass encoding
michaelni
parents: 285
diff changeset
811
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
812 /* 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
813 if(s->ac_pred){
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
814 for(i=0; i<6; i++){
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
815 int j;
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
816 INT16 *ac_val;
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
817
266
252444e5259b optimization
michaelni
parents: 265
diff changeset
818 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
819
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
820 if(dir[i]){
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
821 for(j=1; j<8; j++)
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
822 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
823 }else{
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
824 for(j=1; j<8; j++)
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
825 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
826 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
827 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
828 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
829 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
830 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
831 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
832
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
833 void h263_encode_mb(MpegEncContext * s,
986e461dc072 Initial revision
glantau
parents:
diff changeset
834 DCTELEM block[6][64],
986e461dc072 Initial revision
glantau
parents:
diff changeset
835 int motion_x, int motion_y)
986e461dc072 Initial revision
glantau
parents:
diff changeset
836 {
986e461dc072 Initial revision
glantau
parents:
diff changeset
837 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
838 INT16 pred_dc;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
839 INT16 rec_intradc[6];
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
840 UINT16 *dc_ptr[6];
695
3525da287ee2 adaptive quantization for h263
michaelni
parents: 692
diff changeset
841 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
842
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
843 //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
844 if (!s->mb_intra) {
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
845 /* compute cbp */
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
846 cbp = 0;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
847 for (i = 0; i < 6; i++) {
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
848 if (s->block_last_index[i] >= 0)
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
849 cbp |= 1 << (5 - i);
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
850 }
695
3525da287ee2 adaptive quantization for h263
michaelni
parents: 692
diff changeset
851 if ((cbp | motion_x | motion_y | s->dquant) == 0) {
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
852 /* skip macroblock */
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
853 put_bits(&s->pb, 1, 1);
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
854 return;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
855 }
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
856 put_bits(&s->pb, 1, 0); /* mb coded */
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
857 cbpc = cbp & 3;
695
3525da287ee2 adaptive quantization for h263
michaelni
parents: 692
diff changeset
858 if(s->dquant) cbpc+= 8;
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
859 put_bits(&s->pb,
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
860 inter_MCBPC_bits[cbpc],
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
861 inter_MCBPC_code[cbpc]);
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
862 cbpy = cbp >> 2;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
863 cbpy ^= 0xf;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
864 put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
695
3525da287ee2 adaptive quantization for h263
michaelni
parents: 692
diff changeset
865 if(s->dquant)
3525da287ee2 adaptive quantization for h263
michaelni
parents: 692
diff changeset
866 put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
867
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
868 /* motion vectors: 16x16 mode only now */
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
869 h263_pred_motion(s, 0, &pred_x, &pred_y);
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
870
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
871 if (!s->umvplus) {
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
872 h263_encode_motion(s, motion_x - pred_x, s->f_code);
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
873 h263_encode_motion(s, motion_y - pred_y, s->f_code);
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
874 }
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
875 else {
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
876 h263p_encode_umotion(s, motion_x - pred_x);
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
877 h263p_encode_umotion(s, motion_y - pred_y);
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
878 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
879 /* To prevent Start Code emulation */
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
880 put_bits(&s->pb,1,1);
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
881 }
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
882 } else {
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
883 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
884
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
885 cbp = 0;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
886 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
887 /* Predict DC */
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
888 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
889 INT16 level = block[i][0];
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
890
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
891 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
892 level -= pred_dc;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
893 /* Quant */
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
894 if (level < 0)
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
895 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
896 else
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
897 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
898
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
899 /* AIC can change CBP */
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
900 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
901 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
902 else if (level < -127)
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
903 level = -127;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
904 else if (level > 127)
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
905 level = 127;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
906
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
907 block[i][0] = level;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
908 /* Reconstruction */
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
909 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
910 /* Oddify */
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
911 rec_intradc[i] |= 1;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
912 //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
913 // rec_intradc[i]++;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
914 /* Clipping */
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
915 if (rec_intradc[i] < 0)
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
916 rec_intradc[i] = 0;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
917 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
918 rec_intradc[i] = 2047;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
919
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
920 /* Update AC/DC tables */
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
921 *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
922 }
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
923 /* compute cbp */
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
924 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
925 cbp |= 1 << (5 - i);
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
926 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
927
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
928 cbpc = cbp & 3;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
929 if (s->pict_type == I_TYPE) {
695
3525da287ee2 adaptive quantization for h263
michaelni
parents: 692
diff changeset
930 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
931 put_bits(&s->pb,
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
932 intra_MCBPC_bits[cbpc],
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
933 intra_MCBPC_code[cbpc]);
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
934 } else {
695
3525da287ee2 adaptive quantization for h263
michaelni
parents: 692
diff changeset
935 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
936 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
937 put_bits(&s->pb,
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
938 inter_MCBPC_bits[cbpc + 4],
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
939 inter_MCBPC_code[cbpc + 4]);
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
940 }
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
941 if (s->h263_aic) {
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
942 /* 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
943 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
944 }
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
945 cbpy = cbp >> 2;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
946 put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
695
3525da287ee2 adaptive quantization for h263
michaelni
parents: 692
diff changeset
947 if(s->dquant)
3525da287ee2 adaptive quantization for h263
michaelni
parents: 692
diff changeset
948 put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
949 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
950
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
951 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
952 /* encode each block */
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 293
diff changeset
953 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
954
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
955 /* Update INTRADC for decoding */
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
956 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
957 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
958
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
959 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
960 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
961 }
815
78accc54493b put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents: 770
diff changeset
962 #endif
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
963
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
964 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
965 {
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
966 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
967 INT16 *dc_val, *ac_val;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
968
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
969 /* find prediction */
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
970 if (n < 4) {
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
971 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
972 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
973 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
974 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
975 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
976 scale = s->y_dc_scale;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
977 } else {
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
978 x = s->mb_x + 1;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
979 y = s->mb_y + 1;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
980 wrap = s->mb_width + 2;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
981 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
982 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
983 scale = s->c_dc_scale;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
984 }
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
985 /* B C
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
986 * A X
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
987 */
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
988 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
989 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
990
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
991 /* No prediction outside GOB boundary */
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
992 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
993 c = 1024;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
994 pred_dc = 1024;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
995 /* just DC prediction */
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
996 if (a != 1024 && c != 1024)
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
997 pred_dc = (a + c) >> 1;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
998 else if (a != 1024)
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
999 pred_dc = a;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1000 else
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1001 pred_dc = c;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1002
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1003 /* we assume pred is positive */
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1004 //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
1005 *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
1006 return pred_dc;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1007 }
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1008
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1009
1008
fb6cbb8a04a3 fixing DCTELEM != short
michaelni
parents: 999
diff changeset
1010 void h263_pred_acdc(MpegEncContext * s, DCTELEM *block, int n)
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1011 {
249
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1012 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
1013 INT16 *dc_val, *ac_val, *ac_val1;
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1014
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1015 /* find prediction */
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1016 if (n < 4) {
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1017 x = 2 * s->mb_x + 1 + (n & 1);
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1018 y = 2 * s->mb_y + 1 + ((n & 2) >> 1);
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1019 wrap = s->mb_width * 2 + 2;
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1020 dc_val = s->dc_val[0];
249
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1021 ac_val = s->ac_val[0][0];
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1022 scale = s->y_dc_scale;
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1023 } else {
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1024 x = s->mb_x + 1;
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1025 y = s->mb_y + 1;
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1026 wrap = s->mb_width + 2;
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1027 dc_val = s->dc_val[n - 4 + 1];
249
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1028 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
1029 scale = s->c_dc_scale;
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1030 }
249
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1031
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1032 ac_val += ((y) * wrap + (x)) * 16;
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1033 ac_val1 = ac_val;
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1034
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1035 /* B C
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1036 * A X
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1037 */
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1038 a = dc_val[(x - 1) + (y) * wrap];
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1039 c = dc_val[(x) + (y - 1) * wrap];
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1040
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1041 /* No prediction outside GOB boundary */
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1042 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
1043 c = 1024;
249
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1044 pred_dc = 1024;
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1045 if (s->ac_pred) {
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1046 if (s->h263_aic_dir) {
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1047 /* left prediction */
249
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1048 if (a != 1024) {
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1049 ac_val -= 16;
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1050 for(i=1;i<8;i++) {
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
1051 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
1052 }
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1053 pred_dc = a;
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1054 }
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1055 } else {
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1056 /* top prediction */
249
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1057 if (c != 1024) {
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1058 ac_val -= 16 * wrap;
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1059 for(i=1;i<8;i++) {
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
1060 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
1061 }
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1062 pred_dc = c;
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1063 }
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1064 }
249
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1065 } else {
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1066 /* just DC prediction */
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1067 if (a != 1024 && c != 1024)
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1068 pred_dc = (a + c) >> 1;
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1069 else if (a != 1024)
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1070 pred_dc = a;
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1071 else
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1072 pred_dc = c;
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1073 }
249
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1074
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1075 /* we assume pred is positive */
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1076 block[0]=block[0]*scale + pred_dc;
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1077
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1078 if (block[0] < 0)
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1079 block[0] = 0;
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1080 else if (!(block[0] & 1))
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1081 block[0]++;
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1082
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1083 /* Update AC/DC tables */
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1084 dc_val[(x) + (y) * wrap] = block[0];
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1085
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1086 /* left copy */
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1087 for(i=1;i<8;i++)
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
1088 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
1089 /* top copy */
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1090 for(i=1;i<8;i++)
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
1091 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
1092 }
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1093
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1094 INT16 *h263_pred_motion(MpegEncContext * s, int block,
986e461dc072 Initial revision
glantau
parents:
diff changeset
1095 int *px, int *py)
986e461dc072 Initial revision
glantau
parents:
diff changeset
1096 {
266
252444e5259b optimization
michaelni
parents: 265
diff changeset
1097 int xy, wrap;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1098 INT16 *A, *B, *C, *mot_val;
264
28c5c62b1c4c support decoding (with mplayer) of 3 .mp4 files from mphq
michaelni
parents: 263
diff changeset
1099 static const int off[4]= {2, 1, 1, -1};
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1100
266
252444e5259b optimization
michaelni
parents: 265
diff changeset
1101 wrap = s->block_wrap[0];
252444e5259b optimization
michaelni
parents: 265
diff changeset
1102 xy = s->block_index[block];
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1103
245
a023f78e0cc2 * simplified indexing
kabi
parents: 241
diff changeset
1104 mot_val = s->motion_val[xy];
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1105
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1106 A = s->motion_val[xy - 1];
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1107 /* special case for first (slice) line */
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
1108 if (s->first_slice_line && block<3) {
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1109 // 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
1110 // 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
1111 if(block==0){ //most common case
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1112 if(s->mb_x == s->resync_mb_x){ //rare
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1113 *px= *py = 0;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1114 }else if(s->mb_x + 1 == s->resync_mb_x){ //rare
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1115 C = s->motion_val[xy + off[block] - wrap];
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1116 if(s->mb_x==0){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1117 *px = C[0];
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1118 *py = C[1];
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1119 }else{
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1120 *px = mid_pred(A[0], 0, C[0]);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1121 *py = mid_pred(A[1], 0, C[1]);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1122 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1123 }else{
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1124 *px = A[0];
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1125 *py = A[1];
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1126 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1127 }else if(block==1){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1128 if(s->mb_x + 1 == s->resync_mb_x){ //rare
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1129 C = s->motion_val[xy + off[block] - wrap];
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1130 *px = mid_pred(A[0], 0, C[0]);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1131 *py = mid_pred(A[1], 0, C[1]);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1132 }else{
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1133 *px = A[0];
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1134 *py = A[1];
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1135 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1136 }else{ /* block==2*/
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1137 B = s->motion_val[xy - wrap];
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1138 C = s->motion_val[xy + off[block] - wrap];
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1139 if(s->mb_x == s->resync_mb_x) //rare
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1140 A[0]=A[1]=0;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1141
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1142 *px = mid_pred(A[0], B[0], C[0]);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1143 *py = mid_pred(A[1], B[1], C[1]);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1144 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1145 } else {
264
28c5c62b1c4c support decoding (with mplayer) of 3 .mp4 files from mphq
michaelni
parents: 263
diff changeset
1146 B = s->motion_val[xy - wrap];
28c5c62b1c4c support decoding (with mplayer) of 3 .mp4 files from mphq
michaelni
parents: 263
diff changeset
1147 C = s->motion_val[xy + off[block] - wrap];
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1148 *px = mid_pred(A[0], B[0], C[0]);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1149 *py = mid_pred(A[1], B[1], C[1]);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1150 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1151 return mot_val;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1152 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1153
815
78accc54493b put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents: 770
diff changeset
1154 #ifdef CONFIG_ENCODERS
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
1155 static void h263_encode_motion(MpegEncContext * s, int val, int f_code)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1156 {
702
2cff6fc37716 minor optimization of h263_encode_motion()
michaelni
parents: 701
diff changeset
1157 int range, l, bit_size, sign, code, bits;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1158
986e461dc072 Initial revision
glantau
parents:
diff changeset
1159 if (val == 0) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1160 /* zero vector */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1161 code = 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1162 put_bits(&s->pb, mvtab[code][1], mvtab[code][0]);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1163 } else {
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
1164 bit_size = f_code - 1;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1165 range = 1 << bit_size;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1166 /* modulo encoding */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1167 l = range * 32;
702
2cff6fc37716 minor optimization of h263_encode_motion()
michaelni
parents: 701
diff changeset
1168 #if 1
2cff6fc37716 minor optimization of h263_encode_motion()
michaelni
parents: 701
diff changeset
1169 val+= l;
2cff6fc37716 minor optimization of h263_encode_motion()
michaelni
parents: 701
diff changeset
1170 val&= 2*l-1;
2cff6fc37716 minor optimization of h263_encode_motion()
michaelni
parents: 701
diff changeset
1171 val-= l;
2cff6fc37716 minor optimization of h263_encode_motion()
michaelni
parents: 701
diff changeset
1172 sign = val>>31;
2cff6fc37716 minor optimization of h263_encode_motion()
michaelni
parents: 701
diff changeset
1173 val= (val^sign)-sign;
2cff6fc37716 minor optimization of h263_encode_motion()
michaelni
parents: 701
diff changeset
1174 sign&=1;
2cff6fc37716 minor optimization of h263_encode_motion()
michaelni
parents: 701
diff changeset
1175 #else
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1176 if (val < -l) {
702
2cff6fc37716 minor optimization of h263_encode_motion()
michaelni
parents: 701
diff changeset
1177 val += 2*l;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1178 } else if (val >= l) {
702
2cff6fc37716 minor optimization of h263_encode_motion()
michaelni
parents: 701
diff changeset
1179 val -= 2*l;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1180 }
702
2cff6fc37716 minor optimization of h263_encode_motion()
michaelni
parents: 701
diff changeset
1181
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
1182 assert(val>=-l && val<l);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1183
986e461dc072 Initial revision
glantau
parents:
diff changeset
1184 if (val >= 0) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1185 sign = 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1186 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1187 val = -val;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1188 sign = 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1189 }
702
2cff6fc37716 minor optimization of h263_encode_motion()
michaelni
parents: 701
diff changeset
1190 #endif
312
8cf5507e6ca5 mpeg4 mpeg quantizer support
michaelni
parents: 301
diff changeset
1191 val--;
8cf5507e6ca5 mpeg4 mpeg quantizer support
michaelni
parents: 301
diff changeset
1192 code = (val >> bit_size) + 1;
8cf5507e6ca5 mpeg4 mpeg quantizer support
michaelni
parents: 301
diff changeset
1193 bits = val & (range - 1);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1194
986e461dc072 Initial revision
glantau
parents:
diff changeset
1195 put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1196 if (bit_size > 0) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1197 put_bits(&s->pb, bit_size, bits);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1198 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1199 }
718
16dab8296293 fixing custom quantizer matrix decoding
michaelni
parents: 706
diff changeset
1200
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1201 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1202
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1203 /* Encode MV differences on H.263+ with Unrestricted MV mode */
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1204 static void h263p_encode_umotion(MpegEncContext * s, int val)
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1205 {
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1206 short sval = 0;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1207 short i = 0;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1208 short n_bits = 0;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1209 short temp_val;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1210 int code = 0;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1211 int tcode;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1212
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1213 if ( val == 0)
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1214 put_bits(&s->pb, 1, 1);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1215 else if (val == 1)
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1216 put_bits(&s->pb, 3, 0);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1217 else if (val == -1)
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1218 put_bits(&s->pb, 3, 2);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1219 else {
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1220
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1221 sval = ((val < 0) ? (short)(-val):(short)val);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1222 temp_val = sval;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1223
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1224 while (temp_val != 0) {
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1225 temp_val = temp_val >> 1;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1226 n_bits++;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1227 }
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1228
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1229 i = n_bits - 1;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1230 while (i > 0) {
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1231 tcode = (sval & (1 << (i-1))) >> (i-1);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1232 tcode = (tcode << 1) | 1;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1233 code = (code << 2) | tcode;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1234 i--;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1235 }
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1236 code = ((code << 1) | (val < 0)) << 1;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1237 put_bits(&s->pb, (2*n_bits)+1, code);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1238 //printf("\nVal = %d\tCode = %d", sval, code);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1239 }
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1240 }
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1241
277
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1242 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
1243 {
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1244 int f_code;
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1245 int mv;
815
78accc54493b put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents: 770
diff changeset
1246
78accc54493b put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents: 770
diff changeset
1247 if(mv_penalty==NULL)
78accc54493b put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents: 770
diff changeset
1248 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
1249
277
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1250 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
1251 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
1252 int len;
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1253
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1254 if(mv==0) len= mvtab[0][1];
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1255 else{
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1256 int val, bit_size, range, code;
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1257
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1258 bit_size = s->f_code - 1;
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1259 range = 1 << bit_size;
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1260
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1261 val=mv;
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1262 if (val < 0)
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1263 val = -val;
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1264 val--;
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1265 code = (val >> bit_size) + 1;
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1266 if(code<33){
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1267 len= mvtab[code][1] + 1 + bit_size;
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1268 }else{
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1269 len= mvtab[32][1] + 2 + bit_size;
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1270 }
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1271 }
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1272
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1273 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
1274 }
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1275 }
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1276
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1277 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
1278 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
1279 fcode_tab[mv+MAX_MV]= f_code;
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1280 }
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1281 }
287
32a3dcce2e9b fixing motion estimation with h263p hopefully
michaelni
parents: 286
diff changeset
1282
32a3dcce2e9b fixing motion estimation with h263p hopefully
michaelni
parents: 286
diff changeset
1283 for(mv=0; mv<MAX_MV*2+1; mv++){
32a3dcce2e9b fixing motion estimation with h263p hopefully
michaelni
parents: 286
diff changeset
1284 umv_fcode_tab[mv]= 1;
32a3dcce2e9b fixing motion estimation with h263p hopefully
michaelni
parents: 286
diff changeset
1285 }
277
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1286 }
815
78accc54493b put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents: 770
diff changeset
1287 #endif
277
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1288
468
1e23eae32087 Minor warning cleanup.
mellum
parents: 453
diff changeset
1289 static void init_uni_dc_tab(void)
293
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1290 {
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1291 int level, uni_code, uni_len;
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1292
312
8cf5507e6ca5 mpeg4 mpeg quantizer support
michaelni
parents: 301
diff changeset
1293 for(level=-256; level<256; level++){
293
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1294 int size, v, l;
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1295 /* find number of bits */
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1296 size = 0;
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1297 v = abs(level);
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1298 while (v) {
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1299 v >>= 1;
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1300 size++;
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1301 }
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1302
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1303 if (level < 0)
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1304 l= (-level) ^ ((1 << size) - 1);
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1305 else
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1306 l= level;
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1307
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1308 /* luminance */
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1309 uni_code= DCtab_lum[size][0];
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1310 uni_len = DCtab_lum[size][1];
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1311
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1312 if (size > 0) {
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1313 uni_code<<=size; uni_code|=l;
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1314 uni_len+=size;
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1315 if (size > 8){
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1316 uni_code<<=1; uni_code|=1;
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1317 uni_len++;
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1318 }
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1319 }
1013
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1008
diff changeset
1320 uni_DCtab_lum_bits[level+256]= uni_code;
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1008
diff changeset
1321 uni_DCtab_lum_len [level+256]= uni_len;
293
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1322
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1323 /* chrominance */
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1324 uni_code= DCtab_chrom[size][0];
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1325 uni_len = DCtab_chrom[size][1];
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1326
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1327 if (size > 0) {
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1328 uni_code<<=size; uni_code|=l;
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1329 uni_len+=size;
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1330 if (size > 8){
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1331 uni_code<<=1; uni_code|=1;
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1332 uni_len++;
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1333 }
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1334 }
1013
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1008
diff changeset
1335 uni_DCtab_chrom_bits[level+256]= uni_code;
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1008
diff changeset
1336 uni_DCtab_chrom_len [level+256]= uni_len;
293
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1337
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1338 }
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1339 }
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1340
815
78accc54493b put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents: 770
diff changeset
1341 #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
1342 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
1343 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
1344
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream 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 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
1346 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
1347
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream 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 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
1349 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
1350 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
1351 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
1352 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
1353 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
1354 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
1355 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
1356 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
1357
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1358 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
1359
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream 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 /* 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
1361 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
1362 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
1363 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
1364 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
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 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
1367 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
1368 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
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 #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
1371 /* 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
1372 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
1373 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
1374 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
1375 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
1376 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
1377 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
1378 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
1379 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
1380 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
1381 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
1382
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream 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 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
1384 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
1385 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
1386 }
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1387 }
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1388 #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
1389 #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
1390 /* 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
1391 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
1392 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
1393 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
1394 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
1395 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
1396 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
1397 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
1398 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
1399 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
1400 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
1401
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1402 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
1403 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
1404 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
1405 }
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1406 }
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1407 #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
1408 /* 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
1409 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
1410 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
1411 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
1412 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
1413 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
1414 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
1415 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
1416 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
1417
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1418 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
1419 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
1420 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
1421 }
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1422 }
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1423 }
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1424 }
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1425 }
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1426
277
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1427 void h263_encode_init(MpegEncContext *s)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1428 {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1429 static int done = 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1430
986e461dc072 Initial revision
glantau
parents:
diff changeset
1431 if (!done) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1432 done = 1;
293
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1433
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1434 init_uni_dc_tab();
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1435
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1436 init_rl(&rl_inter);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1437 init_rl(&rl_intra);
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1438 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
1439
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1440 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
1441 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
1442
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1443 init_mv_penalty_and_fcode(s);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1444 }
936
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
1445 s->me.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
1446
287
32a3dcce2e9b fixing motion estimation with h263p hopefully
michaelni
parents: 286
diff changeset
1447 // use fcodes >1 only for mpeg4 & h263 & h263p FIXME
344
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
1448 switch(s->codec_id){
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
1449 case CODEC_ID_MPEG4:
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
1450 s->fcode_tab= fcode_tab;
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
1451 s->min_qcoeff= -2048;
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
1452 s->max_qcoeff= 2047;
945
463f7260b155 trellis quantization
michaelni
parents: 942
diff changeset
1453 s->intra_ac_vlc_length = uni_mpeg4_intra_rl_len;
463f7260b155 trellis quantization
michaelni
parents: 942
diff changeset
1454 s->intra_ac_vlc_last_length= uni_mpeg4_intra_rl_len + 128*64;
463f7260b155 trellis quantization
michaelni
parents: 942
diff changeset
1455 s->inter_ac_vlc_length = uni_mpeg4_inter_rl_len;
463f7260b155 trellis quantization
michaelni
parents: 942
diff changeset
1456 s->inter_ac_vlc_last_length= uni_mpeg4_inter_rl_len + 128*64;
1013
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1008
diff changeset
1457 s->luma_dc_vlc_length= uni_DCtab_lum_len;
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1008
diff changeset
1458 s->chroma_dc_vlc_length= uni_DCtab_chrom_len;
945
463f7260b155 trellis quantization
michaelni
parents: 942
diff changeset
1459 s->ac_esc_length= 7+2+1+6+1+12+1;
344
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
1460 break;
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
1461 case CODEC_ID_H263P:
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
1462 s->fcode_tab= umv_fcode_tab;
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
1463 s->min_qcoeff= -128;
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
1464 s->max_qcoeff= 127;
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
1465 break;
498
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
1466 //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
1467 default: //nothing needed default table allready set in mpegvideo.c
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
1468 s->min_qcoeff= -128;
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
1469 s->max_qcoeff= 127;
498
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
1470 s->y_dc_scale_table=
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
1471 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
344
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
1472 }
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
1473
599
b1a191202f96 mpeg4 mpeg quantizer encoding
michaelni
parents: 598
diff changeset
1474 if(s->mpeg_quant){
b1a191202f96 mpeg4 mpeg quantizer encoding
michaelni
parents: 598
diff changeset
1475 s->intra_quant_bias= 3<<(QUANT_BIAS_SHIFT-3); //(a + x*3/8)/x
b1a191202f96 mpeg4 mpeg quantizer encoding
michaelni
parents: 598
diff changeset
1476 s->inter_quant_bias= 0;
b1a191202f96 mpeg4 mpeg quantizer encoding
michaelni
parents: 598
diff changeset
1477 }else{
b1a191202f96 mpeg4 mpeg quantizer encoding
michaelni
parents: 598
diff changeset
1478 s->intra_quant_bias=0;
b1a191202f96 mpeg4 mpeg quantizer encoding
michaelni
parents: 598
diff changeset
1479 s->inter_quant_bias=-(1<<(QUANT_BIAS_SHIFT-2)); //(a - x/4)/x
b1a191202f96 mpeg4 mpeg quantizer encoding
michaelni
parents: 598
diff changeset
1480 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1481 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1482
1034
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
1483 /**
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
1484 * encodes a 8x8 block.
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
1485 * @param block the 8x8 block
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
1486 * @param n block index (0-3 are luma, 4-5 are chroma)
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
1487 */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1488 static void h263_encode_block(MpegEncContext * s, DCTELEM * block, int n)
986e461dc072 Initial revision
glantau
parents:
diff changeset
1489 {
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1490 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
1491 RLTable *rl;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1492
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1493 rl = &rl_inter;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1494 if (s->mb_intra && !s->h263_aic) {
231
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
1495 /* DC coef */
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
1496 level = block[0];
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1497 /* 255 cannot be represented, so we clamp */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1498 if (level > 254) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1499 level = 254;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1500 block[0] = 254;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1501 }
231
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
1502 /* 0 cannot be represented also */
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
1503 else if (!level) {
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
1504 level = 1;
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
1505 block[0] = 1;
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
1506 }
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
1507 if (level == 128)
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
1508 put_bits(&s->pb, 8, 0xff);
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
1509 else
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
1510 put_bits(&s->pb, 8, level & 0xff);
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
1511 i = 1;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1512 } else {
231
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
1513 i = 0;
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1514 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
1515 rl = &rl_intra_aic;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1516 }
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1517
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1518 /* AC coefs */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1519 last_index = s->block_last_index[n];
986e461dc072 Initial revision
glantau
parents:
diff changeset
1520 last_non_zero = i - 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1521 for (; i <= last_index; i++) {
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
1522 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
1523 level = block[j];
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1524 if (level) {
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1525 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
1526 last = (i == last_index);
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1527 sign = 0;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1528 slevel = level;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1529 if (level < 0) {
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1530 sign = 1;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1531 level = -level;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1532 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1533 code = get_rl_index(rl, last, run, level);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1534 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1535 if (code == rl->n) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1536 put_bits(&s->pb, 1, last);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1537 put_bits(&s->pb, 6, run);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1538 put_bits(&s->pb, 8, slevel & 0xff);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1539 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1540 put_bits(&s->pb, 1, sign);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1541 }
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1542 last_non_zero = i;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1543 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1544 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1545 }
815
78accc54493b put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents: 770
diff changeset
1546 #endif
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1547
986e461dc072 Initial revision
glantau
parents:
diff changeset
1548 /***************************************************/
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
1549 /**
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
1550 * add mpeg4 stuffing bits (01...1)
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
1551 */
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1552 void ff_mpeg4_stuffing(PutBitContext * pbc)
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1553 {
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1554 int length;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1555 put_bits(pbc, 1, 0);
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1556 length= (-get_bit_count(pbc))&7;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1557 if(length) put_bits(pbc, length, (1<<length)-1);
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1558 }
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1559
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
1560 /* must be called before writing the header */
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
1561 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
1562 int time_div, time_mod;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
1563
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
1564 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
1565 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
1566 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
1567
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
1568 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
1569 }
654
850098147a3c export pts from stream if available
michaelni
parents: 648
diff changeset
1570
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
1571 if(s->current_picture.pts)
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
1572 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
1573 else
850098147a3c export pts from stream if available
michaelni
parents: 648
diff changeset
1574 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
1575 time_div= s->time/s->time_increment_resolution;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
1576 time_mod= s->time%s->time_increment_resolution;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
1577
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
1578 if(s->pict_type==B_TYPE){
664
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
1579 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
1580 }else{
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
1581 s->last_time_base= s->time_base;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
1582 s->time_base= time_div;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
1583 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
1584 s->last_non_b_time= s->time;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
1585 }
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
1586 }
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
1587
942
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1588 static void mpeg4_encode_gop_header(MpegEncContext * s){
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1589 int hours, minutes, seconds;
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1590
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1591 put_bits(&s->pb, 16, 0);
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1592 put_bits(&s->pb, 16, GOP_STARTCODE);
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1593
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1594 seconds= s->time/s->time_increment_resolution;
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1595 minutes= seconds/60; seconds %= 60;
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1596 hours= minutes/60; minutes %= 60;
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1597 hours%=24;
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1598
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1599 put_bits(&s->pb, 5, hours);
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1600 put_bits(&s->pb, 6, minutes);
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1601 put_bits(&s->pb, 1, 1);
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1602 put_bits(&s->pb, 6, seconds);
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1603
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1604 put_bits(&s->pb, 1, 0); //closed gov == NO
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1605 put_bits(&s->pb, 1, 0); //broken link == NO
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1606
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1607 ff_mpeg4_stuffing(&s->pb);
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1608 }
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1609
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1610 static void mpeg4_encode_visual_object_header(MpegEncContext * s){
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1611 int profile_and_level_indication;
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1612 int vo_ver_id;
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1613
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1614 if(s->max_b_frames || s->quarter_sample){
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1615 profile_and_level_indication= 0xF1; // adv simple level 1
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1616 vo_ver_id= 5;
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1617 }else{
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1618 profile_and_level_indication= 0x01; // simple level 1
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1619 vo_ver_id= 1;
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1620 }
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1621 //FIXME levels
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1622
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1623 put_bits(&s->pb, 16, 0);
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1624 put_bits(&s->pb, 16, VOS_STARTCODE);
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1625
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1626 put_bits(&s->pb, 8, profile_and_level_indication);
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1627
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1628 put_bits(&s->pb, 16, 0);
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1629 put_bits(&s->pb, 16, VISUAL_OBJ_STARTCODE);
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1630
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1631 put_bits(&s->pb, 1, 1);
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1632 put_bits(&s->pb, 4, vo_ver_id);
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1633 put_bits(&s->pb, 3, 1); //priority
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1634
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1635 put_bits(&s->pb, 4, 1); //visual obj type== video obj
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1636
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1637 put_bits(&s->pb, 1, 0); //video signal type == no clue //FIXME
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1638
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1639 ff_mpeg4_stuffing(&s->pb);
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1640 }
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1641
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1642 static void mpeg4_encode_vol_header(MpegEncContext * s, int vo_number, int vol_number)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1643 {
942
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1644 int vo_ver_id;
322
ce35fd27bbb0 - Versions defined for libav/libavcodec.
pulento
parents: 312
diff changeset
1645 char buf[255];
336
c56b45669214 export delay info
michaelni
parents: 335
diff changeset
1646
942
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1647 if(s->max_b_frames || s->quarter_sample){
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1648 vo_ver_id= 5;
923
3b5d9ecedc73 correct mpeg4 vo type
michaelni
parents: 921
diff changeset
1649 s->vo_type= ADV_SIMPLE_VO_TYPE;
3b5d9ecedc73 correct mpeg4 vo type
michaelni
parents: 921
diff changeset
1650 }else{
942
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1651 vo_ver_id= 1;
923
3b5d9ecedc73 correct mpeg4 vo type
michaelni
parents: 921
diff changeset
1652 s->vo_type= SIMPLE_VO_TYPE;
3b5d9ecedc73 correct mpeg4 vo type
michaelni
parents: 921
diff changeset
1653 }
336
c56b45669214 export delay info
michaelni
parents: 335
diff changeset
1654
263
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1655 put_bits(&s->pb, 16, 0);
942
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1656 put_bits(&s->pb, 16, 0x100 + vo_number); /* video obj */
263
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1657 put_bits(&s->pb, 16, 0);
942
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1658 put_bits(&s->pb, 16, 0x120 + vol_number); /* video obj layer */
263
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1659
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1660 put_bits(&s->pb, 1, 0); /* random access vol */
336
c56b45669214 export delay info
michaelni
parents: 335
diff changeset
1661 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
1662 put_bits(&s->pb, 1, 1); /* is obj layer id= yes */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1663 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
1664 put_bits(&s->pb, 3, 1); /* is obj layer priority */
880
1c32039e7215 aspect ratio cleanup
michaelni
parents: 853
diff changeset
1665
887
19f5b8b7c6d5 fixing aspect
michaelni
parents: 880
diff changeset
1666 float_aspect_to_info(s, s->avctx->aspect_ratio);
880
1c32039e7215 aspect ratio cleanup
michaelni
parents: 853
diff changeset
1667
1c32039e7215 aspect ratio cleanup
michaelni
parents: 853
diff changeset
1668 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
1669 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
1670 {
b4bddbde44f3 aspect (ext. par too) support for h263 and mpeg4 (inc. build becouse of new vars)
al3x
parents: 667
diff changeset
1671 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
1672 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
1673 }
336
c56b45669214 export delay info
michaelni
parents: 335
diff changeset
1674
c56b45669214 export delay info
michaelni
parents: 335
diff changeset
1675 if(s->low_delay){
c56b45669214 export delay info
michaelni
parents: 335
diff changeset
1676 put_bits(&s->pb, 1, 1); /* vol control parameters= yes */
341
bf26081c373c avcodec_flush_buffers()
michaelni
parents: 339
diff changeset
1677 put_bits(&s->pb, 2, 1); /* chroma format YUV 420/YV12 */
336
c56b45669214 export delay info
michaelni
parents: 335
diff changeset
1678 put_bits(&s->pb, 1, s->low_delay);
c56b45669214 export delay info
michaelni
parents: 335
diff changeset
1679 put_bits(&s->pb, 1, 0); /* vbv parameters= no */
c56b45669214 export delay info
michaelni
parents: 335
diff changeset
1680 }else{
c56b45669214 export delay info
michaelni
parents: 335
diff changeset
1681 put_bits(&s->pb, 1, 0); /* vol control parameters= no */
c56b45669214 export delay info
michaelni
parents: 335
diff changeset
1682 }
c56b45669214 export delay info
michaelni
parents: 335
diff changeset
1683
263
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1684 put_bits(&s->pb, 2, RECT_SHAPE); /* vol shape= rectangle */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1685 put_bits(&s->pb, 1, 1); /* marker bit */
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
1686
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
1687 put_bits(&s->pb, 16, s->time_increment_resolution);
263
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1688 if (s->time_increment_bits < 1)
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1689 s->time_increment_bits = 1;
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1690 put_bits(&s->pb, 1, 1); /* marker bit */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1691 put_bits(&s->pb, 1, 0); /* fixed vop rate=no */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1692 put_bits(&s->pb, 1, 1); /* marker bit */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1693 put_bits(&s->pb, 13, s->width); /* vol width */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1694 put_bits(&s->pb, 1, 1); /* marker bit */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1695 put_bits(&s->pb, 13, s->height); /* vol height */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1696 put_bits(&s->pb, 1, 1); /* marker bit */
697
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
1697 put_bits(&s->pb, 1, s->progressive_sequence ? 0 : 1);
263
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1698 put_bits(&s->pb, 1, 1); /* obmc disable */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1699 if (vo_ver_id == 1) {
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1700 put_bits(&s->pb, 1, s->vol_sprite_usage=0); /* sprite enable */
942
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1701 }else{
263
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1702 put_bits(&s->pb, 2, s->vol_sprite_usage=0); /* sprite enable */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1703 }
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
1704
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
1705 s->quant_precision=5;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
1706 put_bits(&s->pb, 1, 0); /* not 8 bit == false */
599
b1a191202f96 mpeg4 mpeg quantizer encoding
michaelni
parents: 598
diff changeset
1707 put_bits(&s->pb, 1, s->mpeg_quant); /* quant type= (0=h263 style)*/
b1a191202f96 mpeg4 mpeg quantizer encoding
michaelni
parents: 598
diff changeset
1708 if(s->mpeg_quant) put_bits(&s->pb, 2, 0); /* no custom matrixes */
b1a191202f96 mpeg4 mpeg quantizer encoding
michaelni
parents: 598
diff changeset
1709
263
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1710 if (vo_ver_id != 1)
936
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
1711 put_bits(&s->pb, 1, s->quarter_sample);
263
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1712 put_bits(&s->pb, 1, 1); /* complexity estimation disable */
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1713 s->resync_marker= s->rtp_mode;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1714 put_bits(&s->pb, 1, s->resync_marker ? 0 : 1);/* resync marker disable */
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1715 put_bits(&s->pb, 1, s->data_partitioning ? 1 : 0);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1716 if(s->data_partitioning){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1717 put_bits(&s->pb, 1, 0); /* no rvlc */
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1718 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1719
263
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1720 if (vo_ver_id != 1){
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1721 put_bits(&s->pb, 1, 0); /* newpred */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1722 put_bits(&s->pb, 1, 0); /* reduced res vop */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1723 }
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1724 put_bits(&s->pb, 1, 0); /* scalability */
676
c3bdb00a98a9 dont store version for bit-exact tests
michaelni
parents: 674
diff changeset
1725
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1726 ff_mpeg4_stuffing(&s->pb);
676
c3bdb00a98a9 dont store version for bit-exact tests
michaelni
parents: 674
diff changeset
1727
c3bdb00a98a9 dont store version for bit-exact tests
michaelni
parents: 674
diff changeset
1728 /* user data */
c3bdb00a98a9 dont store version for bit-exact tests
michaelni
parents: 674
diff changeset
1729 if(!ff_bit_exact){
c3bdb00a98a9 dont store version for bit-exact tests
michaelni
parents: 674
diff changeset
1730 put_bits(&s->pb, 16, 0);
c3bdb00a98a9 dont store version for bit-exact tests
michaelni
parents: 674
diff changeset
1731 put_bits(&s->pb, 16, 0x1B2); /* user_data */
c3bdb00a98a9 dont store version for bit-exact tests
michaelni
parents: 674
diff changeset
1732 sprintf(buf, "FFmpeg%sb%s", FFMPEG_VERSION, LIBAVCODEC_BUILD_STR);
c3bdb00a98a9 dont store version for bit-exact tests
michaelni
parents: 674
diff changeset
1733 put_string(&s->pb, buf);
c3bdb00a98a9 dont store version for bit-exact tests
michaelni
parents: 674
diff changeset
1734 ff_mpeg4_stuffing(&s->pb);
c3bdb00a98a9 dont store version for bit-exact tests
michaelni
parents: 674
diff changeset
1735 }
263
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1736 }
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1737
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1738 /* write mpeg4 VOP header */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1739 void mpeg4_encode_picture_header(MpegEncContext * s, int picture_number)
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1740 {
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
1741 int time_incr;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
1742 int time_div, time_mod;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
1743
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1744 if(s->pict_type==I_TYPE){
953
9eb066d6e0db mpeg4 header encoding bugfix
michaelni
parents: 945
diff changeset
1745 if(!(s->flags&CODEC_FLAG_GLOBAL_HEADER)){
942
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1746 mpeg4_encode_visual_object_header(s);
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1747 mpeg4_encode_vol_header(s, 0, 0);
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1748 }
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1749 mpeg4_encode_gop_header(s);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1750 }
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
1751
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
1752 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
1753
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
1754 //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
1755
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
1756 put_bits(&s->pb, 16, 0); /* vop header */
942
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1757 put_bits(&s->pb, 16, VOP_STARTCODE); /* vop header */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1758 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
1759
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
1760 time_div= s->time/s->time_increment_resolution;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
1761 time_mod= s->time%s->time_increment_resolution;
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
1762 time_incr= time_div - s->last_time_base;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
1763 while(time_incr--)
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
1764 put_bits(&s->pb, 1, 1);
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
1765
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1766 put_bits(&s->pb, 1, 0);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1767
986e461dc072 Initial revision
glantau
parents:
diff changeset
1768 put_bits(&s->pb, 1, 1); /* marker */
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
1769 put_bits(&s->pb, s->time_increment_bits, time_mod); /* time increment */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1770 put_bits(&s->pb, 1, 1); /* marker */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1771 put_bits(&s->pb, 1, 1); /* vop coded */
263
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1772 if ( s->pict_type == P_TYPE
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1773 || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE)) {
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1774 put_bits(&s->pb, 1, s->no_rounding); /* rounding type */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1775 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1776 put_bits(&s->pb, 3, 0); /* intra dc VLC threshold */
697
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
1777 if(!s->progressive_sequence){
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
1778 put_bits(&s->pb, 1, s->top_field_first);
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
1779 put_bits(&s->pb, 1, s->alternate_scan);
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
1780 }
263
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1781 //FIXME sprite stuff
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1782
986e461dc072 Initial revision
glantau
parents:
diff changeset
1783 put_bits(&s->pb, 5, s->qscale);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1784
986e461dc072 Initial revision
glantau
parents:
diff changeset
1785 if (s->pict_type != I_TYPE)
986e461dc072 Initial revision
glantau
parents:
diff changeset
1786 put_bits(&s->pb, 3, s->f_code); /* fcode_for */
263
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1787 if (s->pict_type == B_TYPE)
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1788 put_bits(&s->pb, 3, s->b_code); /* fcode_back */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1789 // printf("****frame %d\n", picture_number);
498
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
1790
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
1791 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
1792 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
1793 s->h_edge_pos= s->width;
5132a4ee50cd different edge positions fixed with edge emu / dr1
michaelni
parents: 575
diff changeset
1794 s->v_edge_pos= s->height;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1795 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1796
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
1797 /**
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
1798 * 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
1799 */
698
e050a053e259 h263_dc_scale() cleanup
michaelni
parents: 697
diff changeset
1800 static void change_qscale(MpegEncContext * s, int dquant)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1801 {
698
e050a053e259 h263_dc_scale() cleanup
michaelni
parents: 697
diff changeset
1802 s->qscale += dquant;
e050a053e259 h263_dc_scale() cleanup
michaelni
parents: 697
diff changeset
1803
e050a053e259 h263_dc_scale() cleanup
michaelni
parents: 697
diff changeset
1804 if (s->qscale < 1)
e050a053e259 h263_dc_scale() cleanup
michaelni
parents: 697
diff changeset
1805 s->qscale = 1;
e050a053e259 h263_dc_scale() cleanup
michaelni
parents: 697
diff changeset
1806 else if (s->qscale > 31)
e050a053e259 h263_dc_scale() cleanup
michaelni
parents: 697
diff changeset
1807 s->qscale = 31;
e050a053e259 h263_dc_scale() cleanup
michaelni
parents: 697
diff changeset
1808
498
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
1809 s->y_dc_scale= s->y_dc_scale_table[ s->qscale ];
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
1810 s->c_dc_scale= s->c_dc_scale_table[ s->qscale ];
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1811 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1812
1034
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
1813 /**
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
1814 * predicts the dc.
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
1815 * @param n block index (0-3 are luma, 4-5 are chroma)
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
1816 * @param dc_val_ptr a pointer to the dc_val entry for the current MB will be stored here
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
1817 * @param dir_ptr pointer to an integer where the prediction direction will be stored
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
1818 * @return the quantized predicted dc
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
1819 */
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
1820 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
1821 {
266
252444e5259b optimization
michaelni
parents: 265
diff changeset
1822 int a, b, c, wrap, pred, scale;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1823 UINT16 *dc_val;
469
a5dd4eae1f0c Revert previous bogus warning fix.
mellum
parents: 468
diff changeset
1824 int dummy;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1825
986e461dc072 Initial revision
glantau
parents:
diff changeset
1826 /* find prediction */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1827 if (n < 4) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1828 scale = s->y_dc_scale;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1829 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1830 scale = s->c_dc_scale;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1831 }
266
252444e5259b optimization
michaelni
parents: 265
diff changeset
1832 wrap= s->block_wrap[n];
252444e5259b optimization
michaelni
parents: 265
diff changeset
1833 dc_val = s->dc_val[0] + s->block_index[n];
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1834
986e461dc072 Initial revision
glantau
parents:
diff changeset
1835 /* B C
986e461dc072 Initial revision
glantau
parents:
diff changeset
1836 * A X
986e461dc072 Initial revision
glantau
parents:
diff changeset
1837 */
266
252444e5259b optimization
michaelni
parents: 265
diff changeset
1838 a = dc_val[ - 1];
252444e5259b optimization
michaelni
parents: 265
diff changeset
1839 b = dc_val[ - 1 - wrap];
252444e5259b optimization
michaelni
parents: 265
diff changeset
1840 c = dc_val[ - wrap];
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1841
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
1842 /* 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
1843 if(s->first_slice_line && n!=3){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
1844 if(n!=2) b=c= 1024;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
1845 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
1846 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
1847 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
1848 if(n==0 || n==4 || n==5)
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
1849 b=1024;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
1850 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
1851
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1852 if (abs(a - b) < abs(b - c)) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1853 pred = c;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1854 *dir_ptr = 1; /* top */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1855 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1856 pred = a;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1857 *dir_ptr = 0; /* left */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1858 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1859 /* we assume pred is positive */
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1860 #ifdef ARCH_X86
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1861 asm volatile (
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1862 "xorl %%edx, %%edx \n\t"
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1863 "mul %%ecx \n\t"
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1864 : "=d" (pred), "=a"(dummy)
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1865 : "a" (pred + (scale >> 1)), "c" (inverse[scale])
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1866 );
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1867 #else
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1868 pred = (pred + (scale >> 1)) / scale;
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1869 #endif
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1870
986e461dc072 Initial revision
glantau
parents:
diff changeset
1871 /* prepare address for prediction update */
266
252444e5259b optimization
michaelni
parents: 265
diff changeset
1872 *dc_val_ptr = &dc_val[0];
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1873
986e461dc072 Initial revision
glantau
parents:
diff changeset
1874 return pred;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1875 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1876
1034
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
1877 /**
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
1878 * predicts the ac.
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
1879 * @param n block index (0-3 are luma, 4-5 are chroma)
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
1880 * @param dir the ac prediction direction
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
1881 */
1008
fb6cbb8a04a3 fixing DCTELEM != short
michaelni
parents: 999
diff changeset
1882 void mpeg4_pred_ac(MpegEncContext * s, DCTELEM *block, int n,
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1883 int dir)
986e461dc072 Initial revision
glantau
parents:
diff changeset
1884 {
266
252444e5259b optimization
michaelni
parents: 265
diff changeset
1885 int i;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1886 INT16 *ac_val, *ac_val1;
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
1887 int8_t * const qscale_table= s->current_picture.qscale_table;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1888
986e461dc072 Initial revision
glantau
parents:
diff changeset
1889 /* find prediction */
266
252444e5259b optimization
michaelni
parents: 265
diff changeset
1890 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1891 ac_val1 = ac_val;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1892 if (s->ac_pred) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1893 if (dir == 0) {
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
1894 const int xy= s->mb_x-1 + s->mb_y*s->mb_width;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1895 /* left prediction */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1896 ac_val -= 16;
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
1897
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
1898 if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
1899 /* same qscale */
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
1900 for(i=1;i<8;i++) {
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
1901 block[s->idct_permutation[i<<3]] += ac_val[i];
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
1902 }
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
1903 }else{
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
1904 /* different qscale, we must rescale */
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
1905 for(i=1;i<8;i++) {
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
1906 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
1907 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1908 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1909 } else {
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
1910 const int xy= s->mb_x + s->mb_y*s->mb_width - s->mb_width;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1911 /* top prediction */
266
252444e5259b optimization
michaelni
parents: 265
diff changeset
1912 ac_val -= 16 * s->block_wrap[n];
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
1913
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
1914 if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
1915 /* same qscale */
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
1916 for(i=1;i<8;i++) {
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
1917 block[s->idct_permutation[i]] += ac_val[i + 8];
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
1918 }
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
1919 }else{
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
1920 /* different qscale, we must rescale */
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
1921 for(i=1;i<8;i++) {
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
1922 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
1923 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1924 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1925 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1926 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1927 /* left copy */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1928 for(i=1;i<8;i++)
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
1929 ac_val1[i ] = block[s->idct_permutation[i<<3]];
591
d3f374218030 fixing mpeg4 mpeg quantizers
michaelni
parents: 582
diff changeset
1930
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1931 /* top copy */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1932 for(i=1;i<8;i++)
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
1933 ac_val1[8 + i] = block[s->idct_permutation[i ]];
591
d3f374218030 fixing mpeg4 mpeg quantizers
michaelni
parents: 582
diff changeset
1934
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1935 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1936
1008
fb6cbb8a04a3 fixing DCTELEM != short
michaelni
parents: 999
diff changeset
1937 static void mpeg4_inv_pred_ac(MpegEncContext * s, DCTELEM *block, int n,
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1938 int dir)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1939 {
266
252444e5259b optimization
michaelni
parents: 265
diff changeset
1940 int i;
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1941 INT16 *ac_val;
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
1942 int8_t * const qscale_table= s->current_picture.qscale_table;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1943
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1944 /* find prediction */
266
252444e5259b optimization
michaelni
parents: 265
diff changeset
1945 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
1946
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1947 if (dir == 0) {
692
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
1948 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
1949 /* left prediction */
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1950 ac_val -= 16;
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
1951 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
1952 /* same qscale */
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
1953 for(i=1;i<8;i++) {
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
1954 block[s->idct_permutation[i<<3]] -= ac_val[i];
692
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
1955 }
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
1956 }else{
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
1957 /* different qscale, we must rescale */
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
1958 for(i=1;i<8;i++) {
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
1959 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
1960 }
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1961 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1962 } else {
692
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
1963 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
1964 /* top prediction */
266
252444e5259b optimization
michaelni
parents: 265
diff changeset
1965 ac_val -= 16 * s->block_wrap[n];
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
1966 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
1967 /* same qscale */
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
1968 for(i=1;i<8;i++) {
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
1969 block[s->idct_permutation[i]] -= ac_val[i + 8];
692
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
1970 }
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
1971 }else{
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
1972 /* different qscale, we must rescale */
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
1973 for(i=1;i<8;i++) {
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
1974 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
1975 }
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1976 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1977 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1978 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1979
1034
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
1980 /**
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
1981 * encodes the dc value.
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
1982 * @param n block index (0-3 are luma, 4-5 are chroma)
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
1983 */
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1984 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
1985 {
293
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1986 #if 1
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1987 // if(level<-255 || level>255) printf("dc overflow\n");
293
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1988 level+=256;
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1989 if (n < 4) {
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1990 /* luminance */
1013
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1008
diff changeset
1991 put_bits(s, uni_DCtab_lum_len[level], uni_DCtab_lum_bits[level]);
293
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1992 } else {
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1993 /* chrominance */
1013
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1008
diff changeset
1994 put_bits(s, uni_DCtab_chrom_len[level], uni_DCtab_chrom_bits[level]);
293
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1995 }
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1996 #else
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1997 int size, v;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1998 /* find number of bits */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1999 size = 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2000 v = abs(level);
986e461dc072 Initial revision
glantau
parents:
diff changeset
2001 while (v) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
2002 v >>= 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2003 size++;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2004 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
2005
986e461dc072 Initial revision
glantau
parents:
diff changeset
2006 if (n < 4) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
2007 /* luminance */
986e461dc072 Initial revision
glantau
parents:
diff changeset
2008 put_bits(&s->pb, DCtab_lum[size][1], DCtab_lum[size][0]);
986e461dc072 Initial revision
glantau
parents:
diff changeset
2009 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
2010 /* chrominance */
986e461dc072 Initial revision
glantau
parents:
diff changeset
2011 put_bits(&s->pb, DCtab_chrom[size][1], DCtab_chrom[size][0]);
986e461dc072 Initial revision
glantau
parents:
diff changeset
2012 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
2013
986e461dc072 Initial revision
glantau
parents:
diff changeset
2014 /* encode remaining bits */
986e461dc072 Initial revision
glantau
parents:
diff changeset
2015 if (size > 0) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
2016 if (level < 0)
986e461dc072 Initial revision
glantau
parents:
diff changeset
2017 level = (-level) ^ ((1 << size) - 1);
986e461dc072 Initial revision
glantau
parents:
diff changeset
2018 put_bits(&s->pb, size, level);
986e461dc072 Initial revision
glantau
parents:
diff changeset
2019 if (size > 8)
986e461dc072 Initial revision
glantau
parents:
diff changeset
2020 put_bits(&s->pb, 1, 1);
986e461dc072 Initial revision
glantau
parents:
diff changeset
2021 }
293
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
2022 #endif
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2023 }
815
78accc54493b put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents: 770
diff changeset
2024 #ifdef CONFIG_ENCODERS
1034
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
2025 /**
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
2026 * encodes a 8x8 block
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
2027 * @param n block index (0-3 are luma, 4-5 are chroma)
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
2028 */
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
2029 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
2030 UINT8 *scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2031 {
751
cbe316f082bc warning fixes
michaelni
parents: 747
diff changeset
2032 int i, last_non_zero;
cbe316f082bc warning fixes
michaelni
parents: 747
diff changeset
2033 #if 0 //variables for the outcommented version
cbe316f082bc warning fixes
michaelni
parents: 747
diff changeset
2034 int code, sign, last;
cbe316f082bc warning fixes
michaelni
parents: 747
diff changeset
2035 #endif
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2036 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
2037 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
2038 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
2039 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
2040
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
2041 if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2042 /* mpeg4 based DC predictor */
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2043 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
2044 if(last_index<1) return;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2045 i = 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2046 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
2047 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
2048 len_tab = uni_mpeg4_intra_rl_len;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2049 } 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
2050 if(last_index<0) return;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2051 i = 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2052 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
2053 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
2054 len_tab = uni_mpeg4_inter_rl_len;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2055 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
2056
986e461dc072 Initial revision
glantau
parents:
diff changeset
2057 /* AC coefs */
986e461dc072 Initial revision
glantau
parents:
diff changeset
2058 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
2059 #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
2060 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
2061 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
2062 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
2063 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
2064 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
2065 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
2066 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
2067 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
2068 }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
2069 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
2070 }
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
2071 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
2072 }
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
2073 }
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
2074 /*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
2075 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
2076 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
2077 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
2078 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
2079 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
2080 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
2081 }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
2082 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
2083 }
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
2084 }
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
2085 #else
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2086 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
2087 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
2088 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
2089 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
2090 int run = i - last_non_zero - 1;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2091 last = (i == last_index);
986e461dc072 Initial revision
glantau
parents:
diff changeset
2092 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
2093 level = slevel;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2094 if (level < 0) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
2095 sign = 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2096 level = -level;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2097 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
2098 code = get_rl_index(rl, last, run, level);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2099 put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2100 if (code == rl->n) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
2101 int level1, run1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2102 level1 = level - rl->max_level[last][run];
986e461dc072 Initial revision
glantau
parents:
diff changeset
2103 if (level1 < 1)
986e461dc072 Initial revision
glantau
parents:
diff changeset
2104 goto esc2;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2105 code = get_rl_index(rl, last, run, level1);
986e461dc072 Initial revision
glantau
parents:
diff changeset
2106 if (code == rl->n) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
2107 esc2:
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2108 put_bits(ac_pb, 1, 1);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2109 if (level > MAX_LEVEL)
986e461dc072 Initial revision
glantau
parents:
diff changeset
2110 goto esc3;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2111 run1 = run - rl->max_run[last][level] - 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2112 if (run1 < 0)
986e461dc072 Initial revision
glantau
parents:
diff changeset
2113 goto esc3;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2114 code = get_rl_index(rl, last, run1, level);
986e461dc072 Initial revision
glantau
parents:
diff changeset
2115 if (code == rl->n) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
2116 esc3:
986e461dc072 Initial revision
glantau
parents:
diff changeset
2117 /* third escape */
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2118 put_bits(ac_pb, 1, 1);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2119 put_bits(ac_pb, 1, last);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2120 put_bits(ac_pb, 6, run);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2121 put_bits(ac_pb, 1, 1);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2122 put_bits(ac_pb, 12, slevel & 0xfff);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2123 put_bits(ac_pb, 1, 1);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2124 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
2125 /* second escape */
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2126 put_bits(ac_pb, 1, 0);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2127 put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2128 put_bits(ac_pb, 1, sign);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2129 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
2130 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
2131 /* first escape */
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2132 put_bits(ac_pb, 1, 0);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2133 put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2134 put_bits(ac_pb, 1, sign);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2135 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
2136 } else {
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2137 put_bits(ac_pb, 1, sign);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2138 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
2139 last_non_zero = i;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2140 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
2141 }
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
2142 #endif
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2143 }
936
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2144
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2145 static inline int mpeg4_get_block_length(MpegEncContext * s, DCTELEM * block, int n, int intra_dc,
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2146 UINT8 *scan_table)
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2147 {
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2148 int i, last_non_zero;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2149 const RLTable *rl;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2150 UINT8 *len_tab;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2151 const int last_index = s->block_last_index[n];
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2152 int len=0;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2153
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2154 if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2155 /* mpeg4 based DC predictor */
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2156 //mpeg4_encode_dc(dc_pb, intra_dc, n); //FIXME
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2157 if(last_index<1) return len;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2158 i = 1;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2159 rl = &rl_intra;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2160 len_tab = uni_mpeg4_intra_rl_len;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2161 } else {
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2162 if(last_index<0) return 0;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2163 i = 0;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2164 rl = &rl_inter;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2165 len_tab = uni_mpeg4_inter_rl_len;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2166 }
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2167
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2168 /* AC coefs */
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2169 last_non_zero = i - 1;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2170 for (; i < last_index; i++) {
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2171 int level = block[ scan_table[i] ];
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2172 if (level) {
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2173 int run = i - last_non_zero - 1;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2174 level+=64;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2175 if((level&(~127)) == 0){
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2176 const int index= UNI_MPEG4_ENC_INDEX(0, run, level);
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2177 len += len_tab[index];
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2178 }else{ //ESC3
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2179 len += 7+2+1+6+1+12+1;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2180 }
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2181 last_non_zero = i;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2182 }
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2183 }
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2184 /*if(i<=last_index)*/{
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2185 int level = block[ scan_table[i] ];
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2186 int run = i - last_non_zero - 1;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2187 level+=64;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2188 if((level&(~127)) == 0){
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2189 const int index= UNI_MPEG4_ENC_INDEX(1, run, level);
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2190 len += len_tab[index];
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2191 }else{ //ESC3
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2192 len += 7+2+1+6+1+12+1;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2193 }
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2194 }
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2195
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2196 return len;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2197 }
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2198
815
78accc54493b put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents: 770
diff changeset
2199 #endif
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2200
986e461dc072 Initial revision
glantau
parents:
diff changeset
2201
986e461dc072 Initial revision
glantau
parents:
diff changeset
2202 /***********************************************/
986e461dc072 Initial revision
glantau
parents:
diff changeset
2203 /* decoding */
986e461dc072 Initial revision
glantau
parents:
diff changeset
2204
986e461dc072 Initial revision
glantau
parents:
diff changeset
2205 static VLC intra_MCBPC_vlc;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2206 static VLC inter_MCBPC_vlc;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2207 static VLC cbpy_vlc;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2208 static VLC mv_vlc;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2209 static VLC dc_lum, dc_chrom;
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
2210 static VLC sprite_trajectory;
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2211 static VLC mb_type_b_vlc;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2212
986e461dc072 Initial revision
glantau
parents:
diff changeset
2213 void init_rl(RLTable *rl)
986e461dc072 Initial revision
glantau
parents:
diff changeset
2214 {
986e461dc072 Initial revision
glantau
parents:
diff changeset
2215 INT8 max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
986e461dc072 Initial revision
glantau
parents:
diff changeset
2216 UINT8 index_run[MAX_RUN+1];
986e461dc072 Initial revision
glantau
parents:
diff changeset
2217 int last, run, level, start, end, i;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2218
986e461dc072 Initial revision
glantau
parents:
diff changeset
2219 /* compute max_level[], max_run[] and index_run[] */
986e461dc072 Initial revision
glantau
parents:
diff changeset
2220 for(last=0;last<2;last++) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
2221 if (last == 0) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
2222 start = 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2223 end = rl->last;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2224 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
2225 start = rl->last;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2226 end = rl->n;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2227 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
2228
986e461dc072 Initial revision
glantau
parents:
diff changeset
2229 memset(max_level, 0, MAX_RUN + 1);
986e461dc072 Initial revision
glantau
parents:
diff changeset
2230 memset(max_run, 0, MAX_LEVEL + 1);
986e461dc072 Initial revision
glantau
parents:
diff changeset
2231 memset(index_run, rl->n, MAX_RUN + 1);
986e461dc072 Initial revision
glantau
parents:
diff changeset
2232 for(i=start;i<end;i++) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
2233 run = rl->table_run[i];
986e461dc072 Initial revision
glantau
parents:
diff changeset
2234 level = rl->table_level[i];
986e461dc072 Initial revision
glantau
parents:
diff changeset
2235 if (index_run[run] == rl->n)
986e461dc072 Initial revision
glantau
parents:
diff changeset
2236 index_run[run] = i;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2237 if (level > max_level[run])
986e461dc072 Initial revision
glantau
parents:
diff changeset
2238 max_level[run] = level;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2239 if (run > max_run[level])
986e461dc072 Initial revision
glantau
parents:
diff changeset
2240 max_run[level] = run;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2241 }
396
fce0a2520551 removed useless header includes - use av memory functions
glantau
parents: 365
diff changeset
2242 rl->max_level[last] = av_malloc(MAX_RUN + 1);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2243 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
2244 rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2245 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
2246 rl->index_run[last] = av_malloc(MAX_RUN + 1);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2247 memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
986e461dc072 Initial revision
glantau
parents:
diff changeset
2248 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
2249 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
2250
986e461dc072 Initial revision
glantau
parents:
diff changeset
2251 void init_vlc_rl(RLTable *rl)
986e461dc072 Initial revision
glantau
parents:
diff changeset
2252 {
542
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2253 int i, q;
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2254
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2255 init_vlc(&rl->vlc, 9, rl->n + 1,
986e461dc072 Initial revision
glantau
parents:
diff changeset
2256 &rl->table_vlc[0][1], 4, 2,
986e461dc072 Initial revision
glantau
parents:
diff changeset
2257 &rl->table_vlc[0][0], 4, 2);
542
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2258
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2259
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2260 for(q=0; q<32; q++){
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2261 int qmul= q*2;
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2262 int qadd= (q-1)|1;
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2263
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2264 if(q==0){
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2265 qmul=1;
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2266 qadd=0;
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2267 }
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2268
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2269 rl->rl_vlc[q]= av_malloc(rl->vlc.table_size*sizeof(RL_VLC_ELEM));
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2270 for(i=0; i<rl->vlc.table_size; i++){
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2271 int code= rl->vlc.table[i][0];
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2272 int len = rl->vlc.table[i][1];
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2273 int level, run;
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2274
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2275 if(len==0){ // illegal code
563
61442627f857 fixes fire.avi & subtitles.avi
michaelni
parents: 549
diff changeset
2276 run= 66;
542
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2277 level= MAX_LEVEL;
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2278 }else if(len<0){ //more bits needed
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2279 run= 0;
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2280 level= code;
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2281 }else{
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2282 if(code==rl->n){ //esc
563
61442627f857 fixes fire.avi & subtitles.avi
michaelni
parents: 549
diff changeset
2283 run= 66;
542
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2284 level= 0;
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2285 }else{
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2286 run= rl->table_run [code] + 1;
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2287 level= rl->table_level[code] * qmul + qadd;
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2288 if(code >= rl->last) run+=192;
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2289 }
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2290 }
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2291 rl->rl_vlc[q][i].len= len;
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2292 rl->rl_vlc[q][i].level= level;
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2293 rl->rl_vlc[q][i].run= run;
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2294 }
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2295 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2296 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
2297
986e461dc072 Initial revision
glantau
parents:
diff changeset
2298 /* init vlcs */
986e461dc072 Initial revision
glantau
parents:
diff changeset
2299
986e461dc072 Initial revision
glantau
parents:
diff changeset
2300 /* XXX: find a better solution to handle static init */
986e461dc072 Initial revision
glantau
parents:
diff changeset
2301 void h263_decode_init_vlc(MpegEncContext *s)
986e461dc072 Initial revision
glantau
parents:
diff changeset
2302 {
986e461dc072 Initial revision
glantau
parents:
diff changeset
2303 static int done = 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2304
986e461dc072 Initial revision
glantau
parents:
diff changeset
2305 if (!done) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
2306 done = 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2307
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
2308 init_vlc(&intra_MCBPC_vlc, INTRA_MCBPC_VLC_BITS, 8,
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2309 intra_MCBPC_bits, 1, 1,
986e461dc072 Initial revision
glantau
parents:
diff changeset
2310 intra_MCBPC_code, 1, 1);
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
2311 init_vlc(&inter_MCBPC_vlc, INTER_MCBPC_VLC_BITS, 25,
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2312 inter_MCBPC_bits, 1, 1,
986e461dc072 Initial revision
glantau
parents:
diff changeset
2313 inter_MCBPC_code, 1, 1);
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
2314 init_vlc(&cbpy_vlc, CBPY_VLC_BITS, 16,
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2315 &cbpy_tab[0][1], 2, 1,
986e461dc072 Initial revision
glantau
parents:
diff changeset
2316 &cbpy_tab[0][0], 2, 1);
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
2317 init_vlc(&mv_vlc, MV_VLC_BITS, 33,
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2318 &mvtab[0][1], 2, 1,
986e461dc072 Initial revision
glantau
parents:
diff changeset
2319 &mvtab[0][0], 2, 1);
986e461dc072 Initial revision
glantau
parents:
diff changeset
2320 init_rl(&rl_inter);
986e461dc072 Initial revision
glantau
parents:
diff changeset
2321 init_rl(&rl_intra);
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
2322 init_rl(&rl_intra_aic);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2323 init_vlc_rl(&rl_inter);
986e461dc072 Initial revision
glantau
parents:
diff changeset
2324 init_vlc_rl(&rl_intra);
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
2325 init_vlc_rl(&rl_intra_aic);
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
2326 init_vlc(&dc_lum, DC_VLC_BITS, 10 /* 13 */,
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2327 &DCtab_lum[0][1], 2, 1,
986e461dc072 Initial revision
glantau
parents:
diff changeset
2328 &DCtab_lum[0][0], 2, 1);
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
2329 init_vlc(&dc_chrom, DC_VLC_BITS, 10 /* 13 */,
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2330 &DCtab_chrom[0][1], 2, 1,
986e461dc072 Initial revision
glantau
parents:
diff changeset
2331 &DCtab_chrom[0][0], 2, 1);
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
2332 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
2333 &sprite_trajectory_tab[0][1], 4, 2,
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
2334 &sprite_trajectory_tab[0][0], 4, 2);
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
2335 init_vlc(&mb_type_b_vlc, MB_TYPE_B_VLC_BITS, 4,
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2336 &mb_type_b_tab[0][1], 2, 1,
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2337 &mb_type_b_tab[0][0], 2, 1);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2338 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
2339 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
2340
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2341 /**
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2342 * 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
2343 */
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2344 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
2345 if (s->height <= 400)
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2346 return 1;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2347 else if (s->height <= 800)
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2348 return 2;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2349 else
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2350 return 4;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2351 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2352
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2353 /**
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2354 * decodes the group of blocks header.
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2355 * @return <0 if an error occured
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2356 */
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2357 static int h263_decode_gob_header(MpegEncContext *s)
162
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
2358 {
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
2359 unsigned int val, gfid;
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2360 int left;
162
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
2361
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
2362 /* Check for GOB Start Code */
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
2363 val = show_bits(&s->gb, 16);
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2364 if(val)
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2365 return -1;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2366
162
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
2367 /* 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
2368 skip_bits(&s->gb, 16); /* Drop the zeros */
1025
1f9afd8b9131 GetBitContext.size is allways multiplied by 8 -> use size_in_bits to avoid useless *8 in a few inner loops
michaelni
parents: 1013
diff changeset
2369 left= s->gb.size_in_bits - get_bits_count(&s->gb);
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2370 //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
2371 for(;left>13; left--){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2372 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
2373 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2374 if(left<=13)
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2375 return -1;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2376
162
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
2377 #ifdef DEBUG
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2378 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
2379 #endif
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2380 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
2381 gfid = get_bits(&s->gb, 2); /* GFID */
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2382 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
2383 if(s->qscale==0)
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2384 return -1;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2385 s->mb_x= 0;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2386 s->mb_y= s->gob_index* s->gob_number;
162
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
2387 #ifdef DEBUG
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2388 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
2389 #endif
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
2390 return 0;
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
2391 }
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
2392
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2393 static inline void memsetw(short *tab, int val, int n)
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2394 {
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2395 int i;
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2396 for(i=0;i<n;i++)
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2397 tab[i] = val;
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2398 }
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2399
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2400 void ff_mpeg4_init_partitions(MpegEncContext *s)
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2401 {
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2402 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
2403 init_put_bits(&s->pb2 , s->pb2_buffer , PB_BUFFER_SIZE, NULL, NULL);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2404 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2405
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2406 void ff_mpeg4_merge_partitions(MpegEncContext *s)
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2407 {
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2408 const int pb2_len = get_bit_count(&s->pb2 );
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2409 const int tex_pb_len= get_bit_count(&s->tex_pb);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2410 const int bits= get_bit_count(&s->pb);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2411
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2412 if(s->pict_type==I_TYPE){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2413 put_bits(&s->pb, 19, DC_MARKER);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2414 s->misc_bits+=19 + pb2_len + bits - s->last_bits;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2415 s->i_tex_bits+= tex_pb_len;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2416 }else{
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2417 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
2418 s->misc_bits+=17 + pb2_len;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2419 s->mv_bits+= bits - s->last_bits;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2420 s->p_tex_bits+= tex_pb_len;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2421 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2422
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2423 flush_put_bits(&s->pb2);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2424 flush_put_bits(&s->tex_pb);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2425
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2426 ff_copy_bits(&s->pb, s->pb2_buffer , pb2_len);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2427 ff_copy_bits(&s->pb, s->tex_pb_buffer, tex_pb_len);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2428 s->last_bits= get_bit_count(&s->pb);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2429 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2430
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2431 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
2432 switch(s->pict_type){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2433 case I_TYPE:
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2434 return 16;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2435 case P_TYPE:
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2436 case S_TYPE:
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2437 return s->f_code+15;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2438 case B_TYPE:
847
f3c369b8ddca reversing header game
michaelni
parents: 821
diff changeset
2439 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
2440 default:
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2441 return -1;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2442 }
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
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2445 void ff_mpeg4_encode_video_packet_header(MpegEncContext *s)
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2446 {
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2447 int mb_num_bits= av_log2(s->mb_num - 1) + 1;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2448
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2449 ff_mpeg4_stuffing(&s->pb);
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2450 put_bits(&s->pb, ff_mpeg4_get_video_packet_prefix_length(s), 0);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2451 put_bits(&s->pb, 1, 1);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2452
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2453 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
2454 put_bits(&s->pb, s->quant_precision, s->qscale);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2455 put_bits(&s->pb, 1, 0); /* no HEC */
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2456 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2457
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2458 /**
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2459 * 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
2460 * @return 0 if not
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2461 */
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2462 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
2463 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
2464
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2465 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
2466 return 0;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2467 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2468
1025
1f9afd8b9131 GetBitContext.size is allways multiplied by 8 -> use size_in_bits to avoid useless *8 in a few inner loops
michaelni
parents: 1013
diff changeset
2469 if(bits_count + 8 >= s->gb.size_in_bits){
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2470 int v= show_bits(&s->gb, 8);
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2471 v|= 0x7F >> (7-(bits_count&7));
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2472
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2473 if(v==0x7F)
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2474 return 1;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2475 }else{
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2476 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
2477 int len;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2478 GetBitContext gb= s->gb;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2479
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2480 skip_bits(&s->gb, 1);
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2481 align_get_bits(&s->gb);
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2482
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2483 for(len=0; len<32; len++){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2484 if(get_bits1(&s->gb)) break;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2485 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2486
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2487 s->gb= gb;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2488
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2489 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
2490 return 1;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2491 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2492 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2493 return 0;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2494 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2495
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2496 /**
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2497 * decodes the next video packet.
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2498 * @return <0 if something went wrong
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2499 */
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2500 static int mpeg4_decode_video_packet_header(MpegEncContext *s)
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2501 {
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2502 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
2503 int header_extension=0, mb_num, len;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2504
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2505 /* is there enough space left for a video packet + header */
1025
1f9afd8b9131 GetBitContext.size is allways multiplied by 8 -> use size_in_bits to avoid useless *8 in a few inner loops
michaelni
parents: 1013
diff changeset
2506 if( get_bits_count(&s->gb) > s->gb.size_in_bits-20) return -1;
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2507
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2508 for(len=0; len<32; len++){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2509 if(get_bits1(&s->gb)) break;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2510 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2511
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2512 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
2513 printf("marker does not match f_code\n");
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2514 return -1;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2515 }
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2516
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2517 if(s->shape != RECT_SHAPE){
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2518 header_extension= get_bits1(&s->gb);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2519 //FIXME more stuff here
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2520 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2521
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2522 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
2523 if(mb_num>=s->mb_num){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2524 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
2525 return -1;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2526 }
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2527 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
2528 s->mb_y= mb_num / s->mb_width;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2529
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2530 if(s->shape != BIN_ONLY_SHAPE){
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2531 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
2532 if(qscale)
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2533 s->qscale= qscale;
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2534 }
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2535
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2536 if(s->shape == RECT_SHAPE){
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2537 header_extension= get_bits1(&s->gb);
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2538 }
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2539 if(header_extension){
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2540 int time_increment;
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2541 int time_incr=0;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2542
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2543 while (get_bits1(&s->gb) != 0)
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2544 time_incr++;
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2545
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2546 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
2547 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
2548 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
2549
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2550 skip_bits(&s->gb, 2); /* vop coding type */
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2551 //FIXME not rect stuff here
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2552
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2553 if(s->shape != BIN_ONLY_SHAPE){
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2554 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
2555 //FIXME dont just ignore everything
821
f5f2e162331c hopefully fixing sprite_warping_points==0
michaelni
parents: 815
diff changeset
2556 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
2557 mpeg4_decode_sprite_trajectory(s);
660
b8e268337a1d parsing resync header extension support
michaelni
parents: 659
diff changeset
2558 fprintf(stderr, "untested\n");
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2559 }
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2560
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2561 //FIXME reduced res stuff here
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2562
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2563 if (s->pict_type != I_TYPE) {
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2564 int f_code = get_bits(&s->gb, 3); /* fcode_for */
660
b8e268337a1d parsing resync header extension support
michaelni
parents: 659
diff changeset
2565 if(f_code==0){
b8e268337a1d parsing resync header extension support
michaelni
parents: 659
diff changeset
2566 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
2567 }
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2568 }
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2569 if (s->pict_type == B_TYPE) {
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2570 int b_code = get_bits(&s->gb, 3);
660
b8e268337a1d parsing resync header extension support
michaelni
parents: 659
diff changeset
2571 if(b_code==0){
b8e268337a1d parsing resync header extension support
michaelni
parents: 659
diff changeset
2572 printf("Error, video packet header damaged (b_code=0)\n");
b8e268337a1d parsing resync header extension support
michaelni
parents: 659
diff changeset
2573 }
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2574 }
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2575 }
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2576 }
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2577 //FIXME new-pred stuff
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2578
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2579 //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
2580
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2581 return 0;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2582 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2583
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2584 void ff_mpeg4_clean_buffers(MpegEncContext *s)
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2585 {
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2586 int c_wrap, c_xy, l_wrap, l_xy;
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2587
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2588 l_wrap= s->block_wrap[0];
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2589 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
2590 c_wrap= s->block_wrap[4];
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2591 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
2592
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2593 #if 0
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2594 /* clean DC */
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2595 memsetw(s->dc_val[0] + l_xy, 1024, l_wrap*2+1);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2596 memsetw(s->dc_val[1] + c_xy, 1024, c_wrap+1);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2597 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
2598 #endif
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2599
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2600 /* clean AC */
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2601 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
2602 memset(s->ac_val[1] + c_xy, 0, (c_wrap +1)*16*sizeof(INT16));
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2603 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
2604
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2605 /* clean MV */
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2606 // we cant clear the MVs as they might be needed by a b frame
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2607 // 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
2608 // 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
2609 s->last_mv[0][0][0]=
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2610 s->last_mv[0][0][1]=
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2611 s->last_mv[1][0][0]=
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2612 s->last_mv[1][0][1]= 0;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2613 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2614
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2615 /**
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2616 * 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
2617 * @return <0 if no resync found
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2618 */
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2619 int ff_h263_resync(MpegEncContext *s){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2620 int left, ret;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2621
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2622 if(s->codec_id==CODEC_ID_MPEG4)
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2623 skip_bits1(&s->gb);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2624
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2625 align_get_bits(&s->gb);
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2626
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2627 if(show_bits(&s->gb, 16)==0){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2628 if(s->codec_id==CODEC_ID_MPEG4)
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2629 ret= mpeg4_decode_video_packet_header(s);
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2630 else
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2631 ret= h263_decode_gob_header(s);
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2632 if(ret>=0)
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2633 return 0;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2634 }
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2635 //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
2636 s->gb= s->last_resync_gb;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2637 align_get_bits(&s->gb);
1025
1f9afd8b9131 GetBitContext.size is allways multiplied by 8 -> use size_in_bits to avoid useless *8 in a few inner loops
michaelni
parents: 1013
diff changeset
2638 left= s->gb.size_in_bits - get_bits_count(&s->gb);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2639
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2640 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
2641 if(show_bits(&s->gb, 16)==0){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2642 GetBitContext bak= s->gb;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2643
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2644 if(s->codec_id==CODEC_ID_MPEG4)
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2645 ret= mpeg4_decode_video_packet_header(s);
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2646 else
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2647 ret= h263_decode_gob_header(s);
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2648 if(ret>=0)
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2649 return 0;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2650
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2651 s->gb= bak;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2652 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2653 skip_bits(&s->gb, 8);
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2654 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2655
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2656 return -1;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2657 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2658
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2659 /**
1034
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
2660 * gets the average motion vector for a GMC MB.
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2661 * @param n either 0 for the x component or 1 for y
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2662 * @returns the average MV for a GMC MB
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2663 */
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2664 static inline int get_amv(MpegEncContext *s, int n){
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2665 int x, y, mb_v, sum, dx, dy, shift;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2666 int len = 1 << (s->f_code + 4);
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2667 const int a= s->sprite_warping_accuracy;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2668
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2669 if(s->real_sprite_warping_points==1){
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2670 if(s->divx_version==500 && s->divx_build==413)
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2671 sum= s->sprite_offset[0][n] / (1<<(a - s->quarter_sample));
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2672 else
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2673 sum= RSHIFT(s->sprite_offset[0][n]<<s->quarter_sample, a);
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2674 }else{
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2675 dx= s->sprite_delta[n][0];
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2676 dy= s->sprite_delta[n][1];
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2677 shift= s->sprite_shift[0];
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2678 if(n) dy -= 1<<(shift + a + 1);
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2679 else dx -= 1<<(shift + a + 1);
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2680 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
2681
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2682 sum=0;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2683 for(y=0; y<16; y++){
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2684 int v;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2685
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2686 v= mb_v + dy*y;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2687 //XXX FIXME optimize
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2688 for(x=0; x<16; x++){
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2689 sum+= v>>shift;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2690 v+= dx;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2691 }
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2692 }
999
74dc4105e147 average motion vector rounding like the reference says and not what the standard says
michaelni
parents: 953
diff changeset
2693 sum= RSHIFT(sum, a+8-s->quarter_sample);
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2694 }
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2695
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2696 if (sum < -len) sum= -len;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2697 else if (sum >= len) sum= len-1;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2698
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2699 return sum;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2700 }
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2701
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2702 /**
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2703 * decodes first partition.
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2704 * @return number of MBs decoded or <0 if an error occured
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2705 */
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2706 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
2707 int mb_num;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2708 static const INT8 quant_tab[4] = { -1, -2, 1, 2 };
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2709
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2710 /* decode first partition */
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2711 mb_num=0;
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2712 s->first_slice_line=1;
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2713 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
2714 ff_init_block_index(s);
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2715 for(; s->mb_x<s->mb_width; s->mb_x++){
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2716 const int xy= s->mb_x + s->mb_y*s->mb_width;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2717 int cbpc;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2718 int dir=0;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2719
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2720 mb_num++;
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2721 ff_update_block_index(s);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2722 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
2723 s->first_slice_line=0;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2724
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2725 if(s->mb_x==0) PRINT_MB_TYPE("\n");
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2726
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2727 if(s->pict_type==I_TYPE){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2728 int i;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2729
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2730 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
2731 return mb_num-1;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2732 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2733
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2734 PRINT_MB_TYPE("I");
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
2735 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
2736 if (cbpc < 0){
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2737
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2738 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
2739 return -1;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2740 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2741 s->cbp_table[xy]= cbpc & 3;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2742 s->mb_type[xy]= MB_TYPE_INTRA;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2743 s->mb_intra = 1;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2744
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2745 if(cbpc & 4) {
698
e050a053e259 h263_dc_scale() cleanup
michaelni
parents: 697
diff changeset
2746 change_qscale(s, quant_tab[get_bits(&s->gb, 2)]);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2747 }
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
2748 s->current_picture.qscale_table[xy]= s->qscale;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2749
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2750 s->mbintra_table[xy]= 1;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2751 for(i=0; i<6; i++){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2752 int dc_pred_dir;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2753 int dc= mpeg4_decode_dc(s, i, &dc_pred_dir);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2754 if(dc < 0){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2755 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
2756 return -1;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2757 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2758 dir<<=1;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2759 if(dc_pred_dir) dir|=1;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2760 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2761 s->pred_dir_table[xy]= dir;
745
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 s->error_status_table[xy]= AC_ERROR;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2764 }else{ /* P/S_TYPE */
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2765 int mx, my, pred_x, pred_y, bits;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2766 INT16 * const mot_val= s->motion_val[s->block_index[0]];
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2767 const int stride= s->block_wrap[0]*2;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2768
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2769 bits= show_bits(&s->gb, 17);
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2770 if(bits==MOTION_MARKER){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2771 return mb_num-1;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2772 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2773 skip_bits1(&s->gb);
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2774 if(bits&0x10000){
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2775 /* skip mb */
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2776 s->mb_type[xy]= MB_TYPE_SKIPED;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2777 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2778 PRINT_MB_TYPE("G");
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2779 mx= get_amv(s, 0);
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2780 my= get_amv(s, 1);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2781 }else{
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2782 PRINT_MB_TYPE("S");
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2783 mx=my=0;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2784 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2785 mot_val[0 ]= mot_val[2 ]=
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2786 mot_val[0+stride]= mot_val[2+stride]= mx;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2787 mot_val[1 ]= mot_val[3 ]=
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2788 mot_val[1+stride]= mot_val[3+stride]= my;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2789
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2790 if(s->mbintra_table[xy])
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2791 ff_clean_intra_table_entries(s);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2792
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2793 s->error_status_table[xy]= AC_ERROR;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2794 continue;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2795 }
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
2796 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
2797 if (cbpc < 0){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2798 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
2799 return -1;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2800 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2801 if (cbpc > 20)
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2802 cbpc+=3;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2803 else if (cbpc == 20)
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2804 fprintf(stderr, "Stuffing !");
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2805 s->cbp_table[xy]= cbpc&(8+3); //8 is dquant
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2806
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2807 s->mb_intra = ((cbpc & 4) != 0);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2808
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2809 if(s->mb_intra){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2810 PRINT_MB_TYPE("I");
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2811 s->mbintra_table[xy]= 1;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2812 s->mb_type[xy]= MB_TYPE_INTRA;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2813 mot_val[0 ]= mot_val[2 ]=
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2814 mot_val[0+stride]= mot_val[2+stride]= 0;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2815 mot_val[1 ]= mot_val[3 ]=
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2816 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
2817 s->error_status_table[xy]= DC_ERROR|AC_ERROR;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2818 }else{
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2819 if(s->mbintra_table[xy])
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2820 ff_clean_intra_table_entries(s);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2821
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2822 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
2823 s->mcsel= get_bits1(&s->gb);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2824 else s->mcsel= 0;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2825
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2826 if ((cbpc & 16) == 0) {
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2827 PRINT_MB_TYPE("P");
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2828 /* 16x16 motion prediction */
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2829 s->mb_type[xy]= MB_TYPE_INTER;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2830
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2831 h263_pred_motion(s, 0, &pred_x, &pred_y);
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2832 if(!s->mcsel){
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2833 mx = h263_decode_motion(s, pred_x, s->f_code);
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2834 if (mx >= 0xffff)
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2835 return -1;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2836
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2837 my = h263_decode_motion(s, pred_y, s->f_code);
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2838 if (my >= 0xffff)
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2839 return -1;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2840 } else {
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2841 mx = get_amv(s, 0);
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2842 my = get_amv(s, 1);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2843 }
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2844
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2845 mot_val[0 ]= mot_val[2 ] =
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2846 mot_val[0+stride]= mot_val[2+stride]= mx;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2847 mot_val[1 ]= mot_val[3 ]=
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2848 mot_val[1+stride]= mot_val[3+stride]= my;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2849 } else {
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2850 int i;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2851 PRINT_MB_TYPE("4");
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2852 s->mb_type[xy]= MB_TYPE_INTER4V;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2853 for(i=0;i<4;i++) {
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2854 INT16 *mot_val= h263_pred_motion(s, i, &pred_x, &pred_y);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2855 mx = h263_decode_motion(s, pred_x, s->f_code);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2856 if (mx >= 0xffff)
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2857 return -1;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2858
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2859 my = h263_decode_motion(s, pred_y, s->f_code);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2860 if (my >= 0xffff)
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2861 return -1;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2862 mot_val[0] = mx;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2863 mot_val[1] = my;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2864 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2865 }
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2866 s->error_status_table[xy]= AC_ERROR;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2867 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2868 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2869 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2870 s->mb_x= 0;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2871 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2872
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2873 return mb_num;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2874 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2875
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2876 /**
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2877 * decode second partition.
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2878 * @return <0 if an error occured
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2879 */
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2880 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
2881 int mb_num=0;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2882 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
2883
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2884 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
2885 s->first_slice_line=1;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2886 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
2887 ff_init_block_index(s);
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2888 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
2889 const int xy= s->mb_x + s->mb_y*s->mb_width;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2890
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2891 mb_num++;
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2892 ff_update_block_index(s);
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2893 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
2894 s->first_slice_line=0;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2895
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2896 if(s->pict_type==I_TYPE){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2897 int ac_pred= get_bits1(&s->gb);
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
2898 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2899 if(cbpy<0){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2900 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
2901 return -1;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2902 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2903
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2904 s->cbp_table[xy]|= cbpy<<2;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2905 s->pred_dir_table[xy]|= ac_pred<<7;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2906 }else{ /* P || S_TYPE */
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2907 if(s->mb_type[xy]&MB_TYPE_INTRA){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2908 int dir=0,i;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2909 int ac_pred = get_bits1(&s->gb);
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
2910 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2911
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2912 if(cbpy<0){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2913 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
2914 return -1;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2915 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2916
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2917 if(s->cbp_table[xy] & 8) {
698
e050a053e259 h263_dc_scale() cleanup
michaelni
parents: 697
diff changeset
2918 change_qscale(s, quant_tab[get_bits(&s->gb, 2)]);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2919 }
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
2920 s->current_picture.qscale_table[xy]= s->qscale;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2921
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2922 for(i=0; i<6; i++){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2923 int dc_pred_dir;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2924 int dc= mpeg4_decode_dc(s, i, &dc_pred_dir);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2925 if(dc < 0){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2926 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
2927 return -1;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2928 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2929 dir<<=1;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2930 if(dc_pred_dir) dir|=1;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2931 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2932 s->cbp_table[xy]&= 3; //remove dquant
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2933 s->cbp_table[xy]|= cbpy<<2;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2934 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
2935 s->error_status_table[xy]&= ~DC_ERROR;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2936 }else if(s->mb_type[xy]&MB_TYPE_SKIPED){
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
2937 s->current_picture.qscale_table[xy]= s->qscale;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2938 s->cbp_table[xy]= 0;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2939 }else{
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
2940 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2941
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2942 if(cbpy<0){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2943 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
2944 return -1;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2945 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2946
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2947 if(s->cbp_table[xy] & 8) {
698
e050a053e259 h263_dc_scale() cleanup
michaelni
parents: 697
diff changeset
2948 change_qscale(s, quant_tab[get_bits(&s->gb, 2)]);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2949 }
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
2950 s->current_picture.qscale_table[xy]= s->qscale;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2951
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2952 s->cbp_table[xy]&= 3; //remove dquant
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2953 s->cbp_table[xy]|= (cbpy^0xf)<<2;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2954 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2955 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2956 }
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2957 if(mb_num >= mb_count) return 0;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2958 s->mb_x= 0;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2959 }
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2960 return 0;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2961 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2962
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2963 /**
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2964 * decodes the first & second partition
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2965 * @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
2966 */
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2967 int ff_mpeg4_decode_partitions(MpegEncContext *s)
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2968 {
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2969 int mb_num;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2970
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2971 mb_num= mpeg4_decode_partition_a(s);
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2972 if(mb_num<0)
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2973 return -1;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2974
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2975 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
2976 fprintf(stderr, "slice below monitor ...\n");
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2977 return -1;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2978 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2979
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2980 s->mb_num_left= mb_num;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2981
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2982 if(s->pict_type==I_TYPE){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2983 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
2984 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
2985 return -1;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2986 }else
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2987 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
2988 }else{
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2989 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
2990 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
2991 return -1;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2992 }else
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2993 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
2994 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2995
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2996 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
2997 return -1;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2998 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2999
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3000 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
3001
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3002 return 0;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3003 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3004
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3005 /**
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3006 * decode partition C of one MB.
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3007 * @return <0 if an error occured
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3008 */
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3009 static int mpeg4_decode_partitioned_mb(MpegEncContext *s, DCTELEM block[6][64])
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3010 {
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3011 int cbp, mb_type;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3012 const int xy= s->mb_x + s->mb_y*s->mb_width;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3013
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3014 mb_type= s->mb_type[xy];
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3015 cbp = s->cbp_table[xy];
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3016
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
3017 if(s->current_picture.qscale_table[xy] != s->qscale){
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
3018 s->qscale= s->current_picture.qscale_table[xy];
698
e050a053e259 h263_dc_scale() cleanup
michaelni
parents: 697
diff changeset
3019 s->y_dc_scale= s->y_dc_scale_table[ s->qscale ];
e050a053e259 h263_dc_scale() cleanup
michaelni
parents: 697
diff changeset
3020 s->c_dc_scale= s->c_dc_scale_table[ s->qscale ];
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3021 }
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3022
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3023 if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3024 int i;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3025 for(i=0; i<4; i++){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3026 s->mv[0][i][0] = s->motion_val[ s->block_index[i] ][0];
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3027 s->mv[0][i][1] = s->motion_val[ s->block_index[i] ][1];
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3028 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3029 s->mb_intra = mb_type&MB_TYPE_INTRA;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3030
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3031 if (mb_type&MB_TYPE_SKIPED) {
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3032 /* skip mb */
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3033 for(i=0;i<6;i++)
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3034 s->block_last_index[i] = -1;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3035 s->mv_dir = MV_DIR_FORWARD;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3036 s->mv_type = MV_TYPE_16X16;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3037 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3038 s->mcsel=1;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3039 s->mb_skiped = 0;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3040 }else{
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3041 s->mcsel=0;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3042 s->mb_skiped = 1;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3043 }
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3044 }else if(s->mb_intra){
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3045 s->ac_pred = s->pred_dir_table[xy]>>7;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3046
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3047 /* decode each block */
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3048 for (i = 0; i < 6; i++) {
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3049 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
3050 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
3051 return -1;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3052 }
718
16dab8296293 fixing custom quantizer matrix decoding
michaelni
parents: 706
diff changeset
3053 cbp+=cbp;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3054 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3055 }else if(!s->mb_intra){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3056 // s->mcsel= 0; //FIXME do we need to init that
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3057
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3058 s->mv_dir = MV_DIR_FORWARD;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3059 if (mb_type&MB_TYPE_INTER4V) {
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3060 s->mv_type = MV_TYPE_8X8;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3061 } else {
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3062 s->mv_type = MV_TYPE_16X16;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3063 }
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3064 /* decode each block */
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3065 for (i = 0; i < 6; i++) {
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3066 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
3067 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
3068 return -1;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3069 }
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3070 cbp+=cbp;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3071 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3072 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3073 } else { /* I-Frame */
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3074 int i;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3075 s->mb_intra = 1;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3076 s->ac_pred = s->pred_dir_table[xy]>>7;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3077
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3078 /* decode each block */
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3079 for (i = 0; i < 6; i++) {
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3080 if(mpeg4_decode_block(s, block[i], i, cbp&32, 1) < 0){
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3081 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
3082 return -1;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3083 }
718
16dab8296293 fixing custom quantizer matrix decoding
michaelni
parents: 706
diff changeset
3084 cbp+=cbp;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3085 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3086 }
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
3087
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3088 s->error_status_table[xy]&= ~AC_ERROR;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3089
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3090 /* per-MB end of slice check */
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3091
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3092 if(--s->mb_num_left <= 0){
1025
1f9afd8b9131 GetBitContext.size is allways multiplied by 8 -> use size_in_bits to avoid useless *8 in a few inner loops
michaelni
parents: 1013
diff changeset
3093 //printf("%06X %d\n", show_bits(&s->gb, 24), s->gb.size_in_bits - get_bits_count(&s->gb));
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3094 if(mpeg4_is_resync(s))
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3095 return SLICE_END;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3096 else
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3097 return SLICE_NOEND;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3098 }else{
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3099 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
3100 return SLICE_END;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3101 else
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3102 return SLICE_OK;
619
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
3103 }
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
3104 }
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3105
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3106 int ff_h263_decode_mb(MpegEncContext *s,
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3107 DCTELEM block[6][64])
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3108 {
986e461dc072 Initial revision
glantau
parents:
diff changeset
3109 int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3110 INT16 *mot_val;
110
e00e5d93457c Added Juergen Keil fix on quant_tab[4] type.
pulento
parents: 79
diff changeset
3111 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
3112
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3113 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
3114
523
c7e4c8b9a3c4 warning fix patch by atmos
michaelni
parents: 498
diff changeset
3115 if(s->mb_x==0) PRINT_MB_TYPE("\n");
359
df0736462b9f move ABS() to common.h
michaelni
parents: 358
diff changeset
3116
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3117 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
3118 if (get_bits1(&s->gb)) {
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3119 /* skip mb */
986e461dc072 Initial revision
glantau
parents:
diff changeset
3120 s->mb_intra = 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3121 for(i=0;i<6;i++)
986e461dc072 Initial revision
glantau
parents:
diff changeset
3122 s->block_last_index[i] = -1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3123 s->mv_dir = MV_DIR_FORWARD;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3124 s->mv_type = MV_TYPE_16X16;
255
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
3125 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
359
df0736462b9f move ABS() to common.h
michaelni
parents: 358
diff changeset
3126 PRINT_MB_TYPE("G");
255
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
3127 s->mcsel=1;
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3128 s->mv[0][0][0]= get_amv(s, 0);
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3129 s->mv[0][0][1]= get_amv(s, 1);
255
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
3130
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
3131 s->mb_skiped = 0;
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
3132 }else{
359
df0736462b9f move ABS() to common.h
michaelni
parents: 358
diff changeset
3133 PRINT_MB_TYPE("S");
255
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
3134 s->mcsel=0;
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
3135 s->mv[0][0][0] = 0;
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
3136 s->mv[0][0][1] = 0;
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
3137 s->mb_skiped = 1;
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
3138 }
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3139 goto end;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3140 }
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
3141 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
3142 //fprintf(stderr, "\tCBPC: %d", cbpc);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3143 if (cbpc < 0)
986e461dc072 Initial revision
glantau
parents:
diff changeset
3144 return -1;
161
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3145 if (cbpc > 20)
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3146 cbpc+=3;
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3147 else if (cbpc == 20)
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3148 fprintf(stderr, "Stuffing !");
144
cb5dabd00ba2 - Bug fix on inter MCBPC table for inter+q.
pulento
parents: 110
diff changeset
3149
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3150 dquant = cbpc & 8;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3151 s->mb_intra = ((cbpc & 4) != 0);
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3152 if (s->mb_intra) goto intra;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3153
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3154 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
3155 s->mcsel= get_bits1(&s->gb);
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3156 else s->mcsel= 0;
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
3157 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3158 cbp = (cbpc & 3) | ((cbpy ^ 0xf) << 2);
986e461dc072 Initial revision
glantau
parents:
diff changeset
3159 if (dquant) {
698
e050a053e259 h263_dc_scale() cleanup
michaelni
parents: 697
diff changeset
3160 change_qscale(s, quant_tab[get_bits(&s->gb, 2)]);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3161 }
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3162 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
3163 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
3164
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3165 s->mv_dir = MV_DIR_FORWARD;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3166 if ((cbpc & 16) == 0) {
619
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
3167 if(s->mcsel){
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
3168 PRINT_MB_TYPE("G");
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
3169 /* 16x16 global motion prediction */
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
3170 s->mv_type = MV_TYPE_16X16;
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3171 mx= get_amv(s, 0);
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3172 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
3173 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
3174 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
3175 }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
3176 PRINT_MB_TYPE("f");
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
3177 /* 16x8 field motion prediction */
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
3178 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
3179
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
3180 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
3181 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
3182
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
3183 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
3184
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
3185 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
3186 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
3187 if (mx >= 0xffff)
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
3188 return -1;
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
3189
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
3190 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
3191 if (my >= 0xffff)
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
3192 return -1;
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
3193
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
3194 s->mv[0][i][0] = mx;
661
a0901e38c564 fixing interlaced mpeg4 decoding
michaelni
parents: 660
diff changeset
3195 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
3196 }
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
3197 }else{
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
3198 PRINT_MB_TYPE("P");
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
3199 /* 16x16 motion prediction */
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
3200 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
3201 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
3202 if (s->umvplus_dec)
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
3203 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
3204 else
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
3205 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
3206
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
3207 if (mx >= 0xffff)
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
3208 return -1;
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
3209
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
3210 if (s->umvplus_dec)
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
3211 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
3212 else
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
3213 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
3214
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
3215 if (my >= 0xffff)
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
3216 return -1;
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
3217 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
3218 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
3219
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
3220 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
3221 skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
255
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
3222 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3223 } else {
359
df0736462b9f move ABS() to common.h
michaelni
parents: 358
diff changeset
3224 PRINT_MB_TYPE("4");
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3225 s->mv_type = MV_TYPE_8X8;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3226 for(i=0;i<4;i++) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
3227 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
3228 if (s->umvplus_dec)
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3229 mx = h263p_decode_umotion(s, pred_x);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3230 else
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3231 mx = h263_decode_motion(s, pred_x, s->f_code);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3232 if (mx >= 0xffff)
986e461dc072 Initial revision
glantau
parents:
diff changeset
3233 return -1;
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3234
79
82e579c37bc3 Moved some H.263+ variables to MpegEncContext to be thread-safe.
pulento
parents: 78
diff changeset
3235 if (s->umvplus_dec)
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3236 my = h263p_decode_umotion(s, pred_y);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3237 else
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3238 my = h263_decode_motion(s, pred_y, s->f_code);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3239 if (my >= 0xffff)
986e461dc072 Initial revision
glantau
parents:
diff changeset
3240 return -1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3241 s->mv[0][i][0] = mx;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3242 s->mv[0][i][1] = my;
79
82e579c37bc3 Moved some H.263+ variables to MpegEncContext to be thread-safe.
pulento
parents: 78
diff changeset
3243 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
3244 skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3245 mot_val[0] = mx;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3246 mot_val[1] = my;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3247 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
3248 }
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3249 } else if(s->pict_type==B_TYPE) {
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3250 int modb1; // first bit of modb
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3251 int modb2; // second bit of modb
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3252 int mb_type;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3253 int xy;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3254
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3255 s->mb_intra = 0; //B-frames never contain intra blocks
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3256 s->mcsel=0; // ... true gmc blocks
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3257
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3258 if(s->mb_x==0){
674
4490bfbb932d interlaced b frames fix
michaelni
parents: 669
diff changeset
3259 for(i=0; i<2; i++){
4490bfbb932d interlaced b frames fix
michaelni
parents: 669
diff changeset
3260 s->last_mv[i][0][0]=
4490bfbb932d interlaced b frames fix
michaelni
parents: 669
diff changeset
3261 s->last_mv[i][0][1]=
4490bfbb932d interlaced b frames fix
michaelni
parents: 669
diff changeset
3262 s->last_mv[i][1][0]=
4490bfbb932d interlaced b frames fix
michaelni
parents: 669
diff changeset
3263 s->last_mv[i][1][1]= 0;
4490bfbb932d interlaced b frames fix
michaelni
parents: 669
diff changeset
3264 }
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3265 }
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3266
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3267 /* if we skipped it in the future P Frame than skip it now too */
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
3268 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
3269
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3270 if(s->mb_skiped){
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3271 /* skip mb */
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3272 for(i=0;i<6;i++)
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3273 s->block_last_index[i] = -1;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3274
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3275 s->mv_dir = MV_DIR_FORWARD;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3276 s->mv_type = MV_TYPE_16X16;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3277 s->mv[0][0][0] = 0;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3278 s->mv[0][0][1] = 0;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3279 s->mv[1][0][0] = 0;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3280 s->mv[1][0][1] = 0;
523
c7e4c8b9a3c4 warning fix patch by atmos
michaelni
parents: 498
diff changeset
3281 PRINT_MB_TYPE("s");
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3282 goto end;
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3283 }
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3284
666
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3285 modb1= get_bits1(&s->gb);
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3286 if(modb1){
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3287 mb_type=4; //like MB_TYPE_B_DIRECT but no vectors coded
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3288 cbp=0;
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3289 }else{
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3290 int field_mv;
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3291
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3292 modb2= get_bits1(&s->gb);
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
3293 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
3294 if(modb2) cbp= 0;
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3295 else cbp= get_bits(&s->gb, 6);
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3296
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3297 if (mb_type!=MB_TYPE_B_DIRECT && cbp) {
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3298 if(get_bits1(&s->gb)){
698
e050a053e259 h263_dc_scale() cleanup
michaelni
parents: 697
diff changeset
3299 change_qscale(s, get_bits1(&s->gb)*4 - 2);
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3300 }
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3301 }
666
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3302 field_mv=0;
664
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
3303
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
3304 if(!s->progressive_sequence){
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
3305 if(cbp)
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
3306 s->interlaced_dct= get_bits1(&s->gb);
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
3307
667
5446a41a00fe 10l (field select readed at the wrong place ...)
michaelni
parents: 666
diff changeset
3308 if(mb_type!=MB_TYPE_B_DIRECT && get_bits1(&s->gb)){
666
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3309 field_mv=1;
667
5446a41a00fe 10l (field select readed at the wrong place ...)
michaelni
parents: 666
diff changeset
3310
5446a41a00fe 10l (field select readed at the wrong place ...)
michaelni
parents: 666
diff changeset
3311 if(mb_type!=MB_TYPE_B_BACKW){
5446a41a00fe 10l (field select readed at the wrong place ...)
michaelni
parents: 666
diff changeset
3312 s->field_select[0][0]= get_bits1(&s->gb);
5446a41a00fe 10l (field select readed at the wrong place ...)
michaelni
parents: 666
diff changeset
3313 s->field_select[0][1]= get_bits1(&s->gb);
5446a41a00fe 10l (field select readed at the wrong place ...)
michaelni
parents: 666
diff changeset
3314 }
5446a41a00fe 10l (field select readed at the wrong place ...)
michaelni
parents: 666
diff changeset
3315 if(mb_type!=MB_TYPE_B_FORW){
5446a41a00fe 10l (field select readed at the wrong place ...)
michaelni
parents: 666
diff changeset
3316 s->field_select[1][0]= get_bits1(&s->gb);
5446a41a00fe 10l (field select readed at the wrong place ...)
michaelni
parents: 666
diff changeset
3317 s->field_select[1][1]= get_bits1(&s->gb);
5446a41a00fe 10l (field select readed at the wrong place ...)
michaelni
parents: 666
diff changeset
3318 }
5446a41a00fe 10l (field select readed at the wrong place ...)
michaelni
parents: 666
diff changeset
3319 }
666
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3320 }
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3321
667
5446a41a00fe 10l (field select readed at the wrong place ...)
michaelni
parents: 666
diff changeset
3322 s->mv_dir = 0;
666
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3323 if(mb_type!=MB_TYPE_B_DIRECT && !field_mv){
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3324 s->mv_type= MV_TYPE_16X16;
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3325 if(mb_type!=MB_TYPE_B_BACKW){
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3326 s->mv_dir = MV_DIR_FORWARD;
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3327
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3328 mx = h263_decode_motion(s, s->last_mv[0][0][0], s->f_code);
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3329 my = h263_decode_motion(s, s->last_mv[0][0][1], s->f_code);
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3330 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
3331 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
3332 }
666
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3333
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3334 if(mb_type!=MB_TYPE_B_FORW){
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3335 s->mv_dir |= MV_DIR_BACKWARD;
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3336
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3337 mx = h263_decode_motion(s, s->last_mv[1][0][0], s->b_code);
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3338 my = h263_decode_motion(s, s->last_mv[1][0][1], s->b_code);
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3339 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
3340 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
3341 }
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3342 if(mb_type!=MB_TYPE_B_DIRECT)
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3343 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
3344 }else if(mb_type!=MB_TYPE_B_DIRECT){
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3345 s->mv_type= MV_TYPE_FIELD;
667
5446a41a00fe 10l (field select readed at the wrong place ...)
michaelni
parents: 666
diff changeset
3346
666
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3347 if(mb_type!=MB_TYPE_B_BACKW){
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3348 s->mv_dir = MV_DIR_FORWARD;
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3349
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3350 for(i=0; i<2; i++){
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3351 mx = h263_decode_motion(s, s->last_mv[0][i][0] , s->f_code);
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3352 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
3353 s->last_mv[0][i][0]= s->mv[0][i][0] = mx;
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3354 s->last_mv[0][i][1]= (s->mv[0][i][1] = my)*2;
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3355 }
667
5446a41a00fe 10l (field select readed at the wrong place ...)
michaelni
parents: 666
diff changeset
3356 }
666
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3357
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3358 if(mb_type!=MB_TYPE_B_FORW){
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3359 s->mv_dir |= MV_DIR_BACKWARD;
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3360
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3361 for(i=0; i<2; i++){
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3362 mx = h263_decode_motion(s, s->last_mv[1][i][0] , s->b_code);
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3363 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
3364 s->last_mv[1][i][0]= s->mv[1][i][0] = mx;
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3365 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
3366 }
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
3367 }
666
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3368 if(mb_type!=MB_TYPE_B_DIRECT)
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3369 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
3370 }
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
3371 }
666
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3372
664
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
3373 if(mb_type==4 || mb_type==MB_TYPE_B_DIRECT){
666
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3374 if(mb_type==4)
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3375 mx=my=0;
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3376 else{
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3377 mx = h263_decode_motion(s, 0, 1);
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3378 my = h263_decode_motion(s, 0, 1);
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3379 }
664
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
3380
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3381 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
936
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
3382 ff_mpeg4_set_direct_mv(s, mx, my);
664
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
3383 }
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
3384
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
3385 if(mb_type<0 || mb_type>4){
364
6b6332e7008a segfault fix for b-frame encoding with height%16!=0
michaelni
parents: 360
diff changeset
3386 printf("illegal MB_type\n");
6b6332e7008a segfault fix for b-frame encoding with height%16!=0
michaelni
parents: 360
diff changeset
3387 return -1;
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3388 }
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3389 } else { /* I-Frame */
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
3390 cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 1);
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3391 if (cbpc < 0)
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3392 return -1;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3393 dquant = cbpc & 4;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3394 s->mb_intra = 1;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3395 intra:
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3396 s->ac_pred = 0;
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
3397 if (s->h263_pred || s->h263_aic) {
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
3398 s->ac_pred = get_bits1(&s->gb);
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
3399 if (s->ac_pred && s->h263_aic)
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
3400 s->h263_aic_dir = get_bits1(&s->gb);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3401 }
591
d3f374218030 fixing mpeg4 mpeg quantizers
michaelni
parents: 582
diff changeset
3402 PRINT_MB_TYPE(s->ac_pred ? "A" : "I");
d3f374218030 fixing mpeg4 mpeg quantizers
michaelni
parents: 582
diff changeset
3403
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
3404 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3405 if(cbpy<0) return -1;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3406 cbp = (cbpc & 3) | (cbpy << 2);
986e461dc072 Initial revision
glantau
parents:
diff changeset
3407 if (dquant) {
698
e050a053e259 h263_dc_scale() cleanup
michaelni
parents: 697
diff changeset
3408 change_qscale(s, quant_tab[get_bits(&s->gb, 2)]);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3409 }
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3410
619
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
3411 if(!s->progressive_sequence)
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
3412 s->interlaced_dct= get_bits1(&s->gb);
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
3413
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
3414 /* decode each block */
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
3415 if (s->h263_pred) {
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
3416 for (i = 0; i < 6; i++) {
718
16dab8296293 fixing custom quantizer matrix decoding
michaelni
parents: 706
diff changeset
3417 if (mpeg4_decode_block(s, block[i], i, cbp&32, 1) < 0)
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
3418 return -1;
718
16dab8296293 fixing custom quantizer matrix decoding
michaelni
parents: 706
diff changeset
3419 cbp+=cbp;
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
3420 }
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
3421 } else {
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
3422 for (i = 0; i < 6; i++) {
718
16dab8296293 fixing custom quantizer matrix decoding
michaelni
parents: 706
diff changeset
3423 if (h263_decode_block(s, block[i], i, cbp&32) < 0)
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
3424 return -1;
718
16dab8296293 fixing custom quantizer matrix decoding
michaelni
parents: 706
diff changeset
3425 cbp+=cbp;
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
3426 }
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
3427 }
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3428 goto end;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3429 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
3430
986e461dc072 Initial revision
glantau
parents:
diff changeset
3431 /* decode each block */
986e461dc072 Initial revision
glantau
parents:
diff changeset
3432 if (s->h263_pred) {
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
3433 for (i = 0; i < 6; i++) {
718
16dab8296293 fixing custom quantizer matrix decoding
michaelni
parents: 706
diff changeset
3434 if (mpeg4_decode_block(s, block[i], i, cbp&32, 0) < 0)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3435 return -1;
718
16dab8296293 fixing custom quantizer matrix decoding
michaelni
parents: 706
diff changeset
3436 cbp+=cbp;
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
3437 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3438 } else {
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
3439 for (i = 0; i < 6; i++) {
718
16dab8296293 fixing custom quantizer matrix decoding
michaelni
parents: 706
diff changeset
3440 if (h263_decode_block(s, block[i], i, cbp&32) < 0)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3441 return -1;
718
16dab8296293 fixing custom quantizer matrix decoding
michaelni
parents: 706
diff changeset
3442 cbp+=cbp;
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
3443 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3444 }
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3445 end:
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3446
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3447 /* per-MB end of slice check */
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3448 if(s->codec_id==CODEC_ID_MPEG4){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3449 if(mpeg4_is_resync(s)){
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
3450 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
3451 return SLICE_OK;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3452 return SLICE_END;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3453 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3454 }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
3455 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
3456
1025
1f9afd8b9131 GetBitContext.size is allways multiplied by 8 -> use size_in_bits to avoid useless *8 in a few inner loops
michaelni
parents: 1013
diff changeset
3457 if(get_bits_count(&s->gb) + 16 > s->gb.size_in_bits){
1f9afd8b9131 GetBitContext.size is allways multiplied by 8 -> use size_in_bits to avoid useless *8 in a few inner loops
michaelni
parents: 1013
diff changeset
3458 v>>= get_bits_count(&s->gb) + 16 - s->gb.size_in_bits;
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3459 }
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
3460
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
3461 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
3462 return SLICE_END;
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3463 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3464
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3465 return SLICE_OK;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3466 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
3467
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3468 static int h263_decode_motion(MpegEncContext * s, int pred, int f_code)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3469 {
656
e47fa3e3f2d5 statistics for forw & back p-MBs instead of just one counter for both
michaelni
parents: 654
diff changeset
3470 int code, val, sign, shift, l;
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
3471 code = get_vlc2(&s->gb, mv_vlc.table, MV_VLC_BITS, 2);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3472 if (code < 0)
986e461dc072 Initial revision
glantau
parents:
diff changeset
3473 return 0xffff;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3474
986e461dc072 Initial revision
glantau
parents:
diff changeset
3475 if (code == 0)
986e461dc072 Initial revision
glantau
parents:
diff changeset
3476 return pred;
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
3477
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
3478 sign = get_bits1(&s->gb);
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3479 shift = f_code - 1;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3480 val = (code - 1) << shift;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3481 if (shift > 0)
986e461dc072 Initial revision
glantau
parents:
diff changeset
3482 val |= get_bits(&s->gb, shift);
986e461dc072 Initial revision
glantau
parents:
diff changeset
3483 val++;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3484 if (sign)
986e461dc072 Initial revision
glantau
parents:
diff changeset
3485 val = -val;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3486 val += pred;
475
6ccc48e4c41b run1 can be <0 bugfix (found by fabrice)
michaelni
parents: 469
diff changeset
3487
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3488 /* modulo decoding */
986e461dc072 Initial revision
glantau
parents:
diff changeset
3489 if (!s->h263_long_vectors) {
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
3490 l = 1 << (f_code + 4);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3491 if (val < -l) {
656
e47fa3e3f2d5 statistics for forw & back p-MBs instead of just one counter for both
michaelni
parents: 654
diff changeset
3492 val += l<<1;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3493 } else if (val >= l) {
656
e47fa3e3f2d5 statistics for forw & back p-MBs instead of just one counter for both
michaelni
parents: 654
diff changeset
3494 val -= l<<1;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3495 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
3496 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
3497 /* horrible h263 long vector mode */
986e461dc072 Initial revision
glantau
parents:
diff changeset
3498 if (pred < -31 && val < -63)
986e461dc072 Initial revision
glantau
parents:
diff changeset
3499 val += 64;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3500 if (pred > 32 && val > 63)
986e461dc072 Initial revision
glantau
parents:
diff changeset
3501 val -= 64;
154
f914f710b8d0 - Fixed a bug on H.263 MV prediction for MB on GOBs limits.
pulento
parents: 144
diff changeset
3502
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3503 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
3504 return val;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3505 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
3506
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3507 /* Decodes RVLC of H.263+ UMV */
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3508 static int h263p_decode_umotion(MpegEncContext * s, int pred)
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3509 {
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3510 int code = 0, sign;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3511
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3512 if (get_bits1(&s->gb)) /* Motion difference = 0 */
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3513 return pred;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3514
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3515 code = 2 + get_bits1(&s->gb);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3516
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3517 while (get_bits1(&s->gb))
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3518 {
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3519 code <<= 1;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3520 code += get_bits1(&s->gb);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3521 }
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3522 sign = code & 1;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3523 code >>= 1;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3524
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3525 code = (sign) ? (pred - code) : (pred + code);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3526 #ifdef DEBUG
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3527 fprintf(stderr,"H.263+ UMV Motion = %d\n", code);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3528 #endif
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3529 return code;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3530
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3531 }
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3532
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3533 static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
986e461dc072 Initial revision
glantau
parents:
diff changeset
3534 int n, int coded)
986e461dc072 Initial revision
glantau
parents:
diff changeset
3535 {
986e461dc072 Initial revision
glantau
parents:
diff changeset
3536 int code, level, i, j, last, run;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3537 RLTable *rl = &rl_inter;
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
3538 const UINT8 *scan_table;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3539
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
3540 scan_table = s->intra_scantable.permutated;
249
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
3541 if (s->h263_aic && s->mb_intra) {
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
3542 rl = &rl_intra_aic;
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
3543 i = 0;
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
3544 if (s->ac_pred) {
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
3545 if (s->h263_aic_dir)
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
3546 scan_table = s->intra_v_scantable.permutated; /* left */
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
3547 else
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
3548 scan_table = s->intra_h_scantable.permutated; /* top */
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
3549 }
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
3550 } else if (s->mb_intra) {
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
3551 /* DC coef */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3552 if (s->h263_rv10 && s->rv10_version == 3 && s->pict_type == I_TYPE) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
3553 int component, diff;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3554 component = (n <= 3 ? 0 : n - 4 + 1);
986e461dc072 Initial revision
glantau
parents:
diff changeset
3555 level = s->last_dc[component];
986e461dc072 Initial revision
glantau
parents:
diff changeset
3556 if (s->rv10_first_dc_coded[component]) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
3557 diff = rv_decode_dc(s, n);
986e461dc072 Initial revision
glantau
parents:
diff changeset
3558 if (diff == 0xffff)
986e461dc072 Initial revision
glantau
parents:
diff changeset
3559 return -1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3560 level += diff;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3561 level = level & 0xff; /* handle wrap round */
986e461dc072 Initial revision
glantau
parents:
diff changeset
3562 s->last_dc[component] = level;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3563 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
3564 s->rv10_first_dc_coded[component] = 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3565 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
3566 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
3567 level = get_bits(&s->gb, 8);
986e461dc072 Initial revision
glantau
parents:
diff changeset
3568 if (level == 255)
986e461dc072 Initial revision
glantau
parents:
diff changeset
3569 level = 128;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3570 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
3571 block[0] = level;
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
3572 i = 1;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3573 } else {
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
3574 i = 0;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3575 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
3576 if (!coded) {
249
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
3577 if (s->mb_intra && s->h263_aic)
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
3578 goto not_coded;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3579 s->block_last_index[n] = i - 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3580 return 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3581 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
3582
986e461dc072 Initial revision
glantau
parents:
diff changeset
3583 for(;;) {
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
3584 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
3585 if (code < 0){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3586 fprintf(stderr, "illegal ac vlc code at %dx%d\n", s->mb_x, s->mb_y);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3587 return -1;
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3588 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3589 if (code == rl->n) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
3590 /* escape */
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
3591 last = get_bits1(&s->gb);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3592 run = get_bits(&s->gb, 6);
986e461dc072 Initial revision
glantau
parents:
diff changeset
3593 level = (INT8)get_bits(&s->gb, 8);
986e461dc072 Initial revision
glantau
parents:
diff changeset
3594 if (s->h263_rv10 && level == -128) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
3595 /* XXX: should patch encoder too */
986e461dc072 Initial revision
glantau
parents:
diff changeset
3596 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
3597 level= (level + ((-1)<<11)) ^ ((-1)<<11); //sign extension
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3598 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
3599 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
3600 run = rl->table_run[code];
986e461dc072 Initial revision
glantau
parents:
diff changeset
3601 level = rl->table_level[code];
986e461dc072 Initial revision
glantau
parents:
diff changeset
3602 last = code >= rl->last;
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
3603 if (get_bits1(&s->gb))
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3604 level = -level;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3605 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
3606 i += run;
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3607 if (i >= 64){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3608 fprintf(stderr, "run overflow at %dx%d\n", s->mb_x, s->mb_y);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3609 return -1;
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3610 }
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
3611 j = scan_table[i];
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3612 block[j] = level;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3613 if (last)
986e461dc072 Initial revision
glantau
parents:
diff changeset
3614 break;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3615 i++;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3616 }
249
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
3617 not_coded:
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
3618 if (s->mb_intra && s->h263_aic) {
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
3619 h263_pred_acdc(s, block, n);
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
3620 i = 63;
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
3621 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3622 s->block_last_index[n] = i;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3623 return 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3624 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
3625
1034
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
3626 /**
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
3627 * decodes the dc value.
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
3628 * @param n block index (0-3 are luma, 4-5 are chroma)
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
3629 * @param dir_ptr the prediction direction will be stored here
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
3630 * @return the quantized dc
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
3631 */
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3632 static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3633 {
986e461dc072 Initial revision
glantau
parents:
diff changeset
3634 int level, pred, code;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3635 UINT16 *dc_val;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3636
986e461dc072 Initial revision
glantau
parents:
diff changeset
3637 if (n < 4)
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
3638 code = get_vlc2(&s->gb, dc_lum.table, DC_VLC_BITS, 1);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3639 else
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
3640 code = get_vlc2(&s->gb, dc_chrom.table, DC_VLC_BITS, 1);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3641 if (code < 0 || code > 9 /* && s->nbit<9 */){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3642 fprintf(stderr, "illegal dc vlc\n");
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3643 return -1;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3644 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3645 if (code == 0) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
3646 level = 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3647 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
3648 level = get_bits(&s->gb, code);
986e461dc072 Initial revision
glantau
parents:
diff changeset
3649 if ((level >> (code - 1)) == 0) /* if MSB not set it is negative*/
986e461dc072 Initial revision
glantau
parents:
diff changeset
3650 level = - (level ^ ((1 << code) - 1));
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3651 if (code > 8){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3652 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
3653 if(s->error_resilience>=2){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3654 fprintf(stderr, "dc marker bit missing\n");
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3655 return -1;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3656 }
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3657 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3658 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3659 }
498
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
3660 pred = ff_mpeg4_pred_dc(s, n, &dc_val, dir_ptr);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3661 level += pred;
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3662 if (level < 0){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3663 if(s->error_resilience>=3){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3664 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
3665 return -1;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3666 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3667 level = 0;
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3668 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3669 if (n < 4) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
3670 *dc_val = level * s->y_dc_scale;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3671 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
3672 *dc_val = level * s->c_dc_scale;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3673 }
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3674 if(s->error_resilience>=3){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3675 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
3676 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
3677 return -1;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3678 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3679 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3680 return level;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3681 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
3682
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3683 /**
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3684 * decodes a block.
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3685 * @return <0 if an error occured
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3686 */
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3687 static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
3688 int n, int coded, int intra)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3689 {
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3690 int level, i, last, run;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3691 int dc_pred_dir;
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
3692 RLTable * rl;
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
3693 RL_VLC_ELEM * rl_vlc;
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
3694 const UINT8 * scan_table;
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3695 int qmul, qadd;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3696
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
3697 if(intra) {
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3698 /* DC coef */
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3699 if(s->partitioned_frame){
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3700 level = s->dc_val[0][ s->block_index[n] ];
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3701 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
3702 else level= (level + (s->c_dc_scale>>1))/s->c_dc_scale;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3703 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
3704 }else{
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3705 level = mpeg4_decode_dc(s, n, &dc_pred_dir);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3706 if (level < 0)
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3707 return -1;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3708 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3709 block[0] = level;
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3710 i = 0;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3711 if (!coded)
986e461dc072 Initial revision
glantau
parents:
diff changeset
3712 goto not_coded;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3713 rl = &rl_intra;
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3714 rl_vlc = rl_intra.rl_vlc[0];
718
16dab8296293 fixing custom quantizer matrix decoding
michaelni
parents: 706
diff changeset
3715 if (s->ac_pred) {
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3716 if (dc_pred_dir == 0)
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
3717 scan_table = s->intra_v_scantable.permutated; /* left */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3718 else
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
3719 scan_table = s->intra_h_scantable.permutated; /* top */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3720 } else {
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
3721 scan_table = s->intra_scantable.permutated;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3722 }
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3723 qmul=1;
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3724 qadd=0;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3725 } else {
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3726 i = -1;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3727 if (!coded) {
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3728 s->block_last_index[n] = i;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3729 return 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3730 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
3731 rl = &rl_inter;
661
a0901e38c564 fixing interlaced mpeg4 decoding
michaelni
parents: 660
diff changeset
3732
718
16dab8296293 fixing custom quantizer matrix decoding
michaelni
parents: 706
diff changeset
3733 scan_table = s->intra_scantable.permutated;
661
a0901e38c564 fixing interlaced mpeg4 decoding
michaelni
parents: 660
diff changeset
3734
591
d3f374218030 fixing mpeg4 mpeg quantizers
michaelni
parents: 582
diff changeset
3735 if(s->mpeg_quant){
d3f374218030 fixing mpeg4 mpeg quantizers
michaelni
parents: 582
diff changeset
3736 qmul=1;
d3f374218030 fixing mpeg4 mpeg quantizers
michaelni
parents: 582
diff changeset
3737 qadd=0;
d3f374218030 fixing mpeg4 mpeg quantizers
michaelni
parents: 582
diff changeset
3738 rl_vlc = rl_inter.rl_vlc[0];
d3f374218030 fixing mpeg4 mpeg quantizers
michaelni
parents: 582
diff changeset
3739 }else{
d3f374218030 fixing mpeg4 mpeg quantizers
michaelni
parents: 582
diff changeset
3740 qmul = s->qscale << 1;
d3f374218030 fixing mpeg4 mpeg quantizers
michaelni
parents: 582
diff changeset
3741 qadd = (s->qscale - 1) | 1;
d3f374218030 fixing mpeg4 mpeg quantizers
michaelni
parents: 582
diff changeset
3742 rl_vlc = rl_inter.rl_vlc[s->qscale];
d3f374218030 fixing mpeg4 mpeg quantizers
michaelni
parents: 582
diff changeset
3743 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3744 }
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3745 {
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3746 OPEN_READER(re, &s->gb);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3747 for(;;) {
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3748 UPDATE_CACHE(re, &s->gb);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3749 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3750 if (level==0) {
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3751 int cache;
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3752 cache= GET_CACHE(re, &s->gb);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3753 /* escape */
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3754 if (cache&0x80000000) {
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3755 if (cache&0x40000000) {
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3756 /* third escape */
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3757 SKIP_CACHE(re, &s->gb, 2);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3758 last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3759 run= SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3760 SKIP_COUNTER(re, &s->gb, 2+1+6);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3761 UPDATE_CACHE(re, &s->gb);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3762
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3763 if(SHOW_UBITS(re, &s->gb, 1)==0){
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3764 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
3765 return -1;
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3766 }; SKIP_CACHE(re, &s->gb, 1);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3767
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3768 level= SHOW_SBITS(re, &s->gb, 12); SKIP_CACHE(re, &s->gb, 12);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3769
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3770 if(SHOW_UBITS(re, &s->gb, 1)==0){
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3771 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
3772 return -1;
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3773 }; LAST_SKIP_CACHE(re, &s->gb, 1);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3774
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3775 SKIP_COUNTER(re, &s->gb, 1+12+1);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3776
597
d5d0c11ea4cf fixing level overflow check for qp=1
michaelni
parents: 591
diff changeset
3777 if(level*s->qscale>1024 || level*s->qscale<-1024){
d5d0c11ea4cf fixing level overflow check for qp=1
michaelni
parents: 591
diff changeset
3778 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
3779 return -1;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3780 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3781 #if 1
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3782 {
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3783 const int abs_level= ABS(level);
921
f633377858b6 ump4 decoding fixed
michaelni
parents: 906
diff changeset
3784 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
3785 const int run1= run - rl->max_run[last][abs_level] - 1;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3786 if(abs_level <= rl->max_level[last][run]){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3787 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
3788 return -1;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3789 }
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
3790 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
3791 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
3792 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
3793 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
3794 }
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
3795 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
3796 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
3797 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
3798 }
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3799 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3800 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3801 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3802 #endif
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3803 if (level>0) level= level * qmul + qadd;
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3804 else level= level * qmul - qadd;
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3805
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3806 i+= run + 1;
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3807 if(last) i+=192;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3808 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
3809 /* second escape */
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3810 #if MIN_CACHE_BITS < 20
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3811 LAST_SKIP_BITS(re, &s->gb, 2);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3812 UPDATE_CACHE(re, &s->gb);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3813 #else
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3814 SKIP_BITS(re, &s->gb, 2);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3815 #endif
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3816 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3817 i+= run + rl->max_run[run>>7][level/qmul] +1; //FIXME opt indexing
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3818 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3819 LAST_SKIP_BITS(re, &s->gb, 1);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3820 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
3821 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
3822 /* first escape */
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3823 #if MIN_CACHE_BITS < 19
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3824 LAST_SKIP_BITS(re, &s->gb, 1);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3825 UPDATE_CACHE(re, &s->gb);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3826 #else
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3827 SKIP_BITS(re, &s->gb, 1);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3828 #endif
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3829 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3830 i+= run;
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3831 level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//FIXME opt indexing
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3832 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3833 LAST_SKIP_BITS(re, &s->gb, 1);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3834 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
3835 } else {
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3836 i+= run;
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3837 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3838 LAST_SKIP_BITS(re, &s->gb, 1);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3839 }
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3840 if (i > 62){
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3841 i-= 192;
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3842 if(i&(~63)){
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3843 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
3844 return -1;
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3845 }
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3846
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3847 block[scan_table[i]] = level;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3848 break;
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3849 }
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3850
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3851 block[scan_table[i]] = level;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3852 }
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3853 CLOSE_READER(re, &s->gb);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3854 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3855 not_coded:
986e461dc072 Initial revision
glantau
parents:
diff changeset
3856 if (s->mb_intra) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
3857 mpeg4_pred_ac(s, block, n, dc_pred_dir);
986e461dc072 Initial revision
glantau
parents:
diff changeset
3858 if (s->ac_pred) {
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3859 i = 63; /* XXX: not optimal */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3860 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
3861 }
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3862 s->block_last_index[n] = i;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3863 return 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3864 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
3865
986e461dc072 Initial revision
glantau
parents:
diff changeset
3866 /* most is hardcoded. should extend to handle all h263 streams */
986e461dc072 Initial revision
glantau
parents:
diff changeset
3867 int h263_decode_picture_header(MpegEncContext *s)
986e461dc072 Initial revision
glantau
parents:
diff changeset
3868 {
986e461dc072 Initial revision
glantau
parents:
diff changeset
3869 int format, width, height;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3870
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3871 /* picture start code */
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3872 if (get_bits(&s->gb, 22) != 0x20) {
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3873 fprintf(stderr, "Bad picture start code\n");
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3874 return -1;
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3875 }
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3876 /* temporal reference */
231
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
3877 s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3878
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3879 /* PTYPE starts here */
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3880 if (get_bits1(&s->gb) != 1) {
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3881 /* marker */
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3882 fprintf(stderr, "Bad marker\n");
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3883 return -1;
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3884 }
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3885 if (get_bits1(&s->gb) != 0) {
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3886 fprintf(stderr, "Bad H263 id\n");
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3887 return -1; /* h263 id */
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3888 }
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
3889 skip_bits1(&s->gb); /* split screen off */
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
3890 skip_bits1(&s->gb); /* camera off */
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
3891 skip_bits1(&s->gb); /* freeze picture release off */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3892
155
3c3449bce692 - Bug fix on MV prediction for MPEG4 caused by new H.263 GOB code.
pulento
parents: 154
diff changeset
3893 /* Reset GOB number */
154
f914f710b8d0 - Fixed a bug on H.263 MV prediction for MB on GOBs limits.
pulento
parents: 144
diff changeset
3894 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
3895
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3896 format = get_bits(&s->gb, 3);
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3897 /*
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3898 0 forbidden
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3899 1 sub-QCIF
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3900 10 QCIF
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3901 7 extended PTYPE (PLUSPTYPE)
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3902 */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3903
161
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3904 if (format != 7 && format != 6) {
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3905 s->h263_plus = 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3906 /* H.263v1 */
986e461dc072 Initial revision
glantau
parents:
diff changeset
3907 width = h263_format[format][0];
986e461dc072 Initial revision
glantau
parents:
diff changeset
3908 height = h263_format[format][1];
986e461dc072 Initial revision
glantau
parents:
diff changeset
3909 if (!width)
986e461dc072 Initial revision
glantau
parents:
diff changeset
3910 return -1;
161
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3911
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3912 s->width = width;
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3913 s->height = height;
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
3914 s->pict_type = I_TYPE + get_bits1(&s->gb);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3915
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
3916 s->unrestricted_mv = get_bits1(&s->gb);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3917 s->h263_long_vectors = s->unrestricted_mv;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3918
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3919 if (get_bits1(&s->gb) != 0) {
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3920 fprintf(stderr, "H263 SAC not supported\n");
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3921 return -1; /* SAC: off */
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3922 }
161
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3923 if (get_bits1(&s->gb) != 0) {
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3924 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
3925 }
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3926
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3927 if (get_bits1(&s->gb) != 0) {
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3928 fprintf(stderr, "H263 PB frame not supported\n");
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3929 return -1; /* not PB frame */
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3930 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3931 s->qscale = get_bits(&s->gb, 5);
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
3932 skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3933 } else {
161
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3934 int ufep;
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3935
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3936 /* H.263v2 */
161
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3937 s->h263_plus = 1;
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3938 ufep = get_bits(&s->gb, 3); /* Update Full Extended PTYPE */
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3939
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3940 /* 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
3941 if (ufep == 1) {
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3942 /* OPPTYPE */
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3943 format = get_bits(&s->gb, 3);
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3944 dprintf("ufep=1, format: %d\n", format);
161
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3945 skip_bits(&s->gb,1); /* Custom PCF */
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3946 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
3947 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
3948 if (get_bits1(&s->gb) != 0) {
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3949 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
3950 }
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
3951 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
3952 s->h263_aic = 1;
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
3953 }
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3954
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
3955 skip_bits(&s->gb, 7);
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3956 /* these are the 7 bits: (in order of appearence */
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3957 /* Deblocking Filter */
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3958 /* Slice Structured */
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3959 /* Reference Picture Selection */
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3960 /* Independent Segment Decoding */
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3961 /* Alternative Inter VLC */
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3962 /* Modified Quantization */
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3963 /* Prevent start code emulation */
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3964
161
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3965 skip_bits(&s->gb, 3); /* Reserved */
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3966 } else if (ufep != 0) {
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3967 fprintf(stderr, "Bad UFEP type (%d)\n", ufep);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3968 return -1;
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3969 }
161
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3970
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3971 /* MPPTYPE */
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3972 s->pict_type = get_bits(&s->gb, 3) + I_TYPE;
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3973 dprintf("pict_type: %d\n", s->pict_type);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3974 if (s->pict_type != I_TYPE &&
986e461dc072 Initial revision
glantau
parents:
diff changeset
3975 s->pict_type != P_TYPE)
986e461dc072 Initial revision
glantau
parents:
diff changeset
3976 return -1;
250
3449316664b5 - Bug fix on RTYPE (rounding type) not being honoured by H.263+ decoder.
pulento
parents: 249
diff changeset
3977 skip_bits(&s->gb, 2);
3449316664b5 - Bug fix on RTYPE (rounding type) not being honoured by H.263+ decoder.
pulento
parents: 249
diff changeset
3978 s->no_rounding = get_bits1(&s->gb);
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3979 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
3980 skip_bits(&s->gb, 4);
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3981
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3982 /* Get the picture dimensions */
161
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3983 if (ufep) {
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3984 if (format == 6) {
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3985 /* Custom Picture Format (CPFMT) */
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3986 s->aspect_ratio_info = get_bits(&s->gb, 4);
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3987 dprintf("aspect: %d\n", s->aspect_ratio_info);
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3988 /* aspect ratios:
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3989 0 - forbidden
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3990 1 - 1:1
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3991 2 - 12:11 (CIF 4:3)
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3992 3 - 10:11 (525-type 4:3)
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3993 4 - 16:11 (CIF 16:9)
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3994 5 - 40:33 (525-type 16:9)
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3995 6-14 - reserved
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3996 */
161
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3997 width = (get_bits(&s->gb, 9) + 1) * 4;
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3998 skip_bits1(&s->gb);
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3999 height = get_bits(&s->gb, 9) * 4;
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4000 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
4001 if (s->aspect_ratio_info == FF_ASPECT_EXTENDED) {
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4002 /* aspected dimensions */
669
b4bddbde44f3 aspect (ext. par too) support for h263 and mpeg4 (inc. build becouse of new vars)
al3x
parents: 667
diff changeset
4003 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
4004 s->aspected_height = get_bits(&s->gb, 8);
887
19f5b8b7c6d5 fixing aspect
michaelni
parents: 880
diff changeset
4005 }else{
19f5b8b7c6d5 fixing aspect
michaelni
parents: 880
diff changeset
4006 s->aspected_width = pixel_aspect[s->aspect_ratio_info][0];
19f5b8b7c6d5 fixing aspect
michaelni
parents: 880
diff changeset
4007 s->aspected_height= pixel_aspect[s->aspect_ratio_info][1];
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4008 }
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4009 } else {
161
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
4010 width = h263_format[format][0];
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
4011 height = h263_format[format][1];
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
4012 }
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
4013 if ((width == 0) || (height == 0))
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
4014 return -1;
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
4015 s->width = width;
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
4016 s->height = height;
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
4017 if (s->umvplus_dec) {
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
4018 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
4019 }
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
4020 }
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
4021
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4022 s->qscale = get_bits(&s->gb, 5);
986e461dc072 Initial revision
glantau
parents:
diff changeset
4023 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
4024 /* PEI */
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
4025 while (get_bits1(&s->gb) != 0) {
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
4026 skip_bits(&s->gb, 8);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4027 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
4028 s->f_code = 1;
498
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
4029
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
4030 if(s->h263_aic){
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
4031 s->y_dc_scale_table=
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
4032 s->c_dc_scale_table= h263_aic_dc_scale_table;
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
4033 }else{
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
4034 s->y_dc_scale_table=
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
4035 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
4036 }
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
4037
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4038 return 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
4039 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
4040
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
4041 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
4042 {
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
4043 int i;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
4044 int a= 2<<s->sprite_warping_accuracy;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
4045 int rho= 3-s->sprite_warping_accuracy;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
4046 int r=16/a;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
4047 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
4048 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
4049 int sprite_ref[4][2];
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
4050 int virtual_ref[2][2];
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4051 int w2, h2, w3, h3;
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
4052 int alpha=0, beta=0;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
4053 int w= s->width;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
4054 int h= s->height;
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4055 int min_ab;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4056
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
4057 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
4058 int length;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
4059 int x=0, y=0;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
4060
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
4061 length= get_vlc(&s->gb, &sprite_trajectory);
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
4062 if(length){
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
4063 x= get_bits(&s->gb, length);
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4064
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
4065 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
4066 x = - (x ^ ((1 << length) - 1));
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
4067 }
255
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
4068 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
4069
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
4070 length= get_vlc(&s->gb, &sprite_trajectory);
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
4071 if(length){
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
4072 y=get_bits(&s->gb, length);
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4073
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
4074 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
4075 y = - (y ^ ((1 << length) - 1));
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
4076 }
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
4077 skip_bits1(&s->gb); /* marker bit */
255
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
4078 //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
4079 d[i][0]= x;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
4080 d[i][1]= y;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
4081 }
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
4082
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
4083 while((1<<alpha)<w) alpha++;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
4084 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
4085 w2= 1<<alpha;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
4086 h2= 1<<beta;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
4087
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
4088 // Note, the 4th point isnt used for GMC
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
4089 if(s->divx_version==500 && s->divx_build==413){
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
4090 sprite_ref[0][0]= a*vop_ref[0][0] + d[0][0];
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
4091 sprite_ref[0][1]= a*vop_ref[0][1] + d[0][1];
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
4092 sprite_ref[1][0]= a*vop_ref[1][0] + d[0][0] + d[1][0];
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
4093 sprite_ref[1][1]= a*vop_ref[1][1] + d[0][1] + d[1][1];
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
4094 sprite_ref[2][0]= a*vop_ref[2][0] + d[0][0] + d[2][0];
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
4095 sprite_ref[2][1]= a*vop_ref[2][1] + d[0][1] + d[2][1];
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
4096 } else {
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
4097 sprite_ref[0][0]= (a>>1)*(2*vop_ref[0][0] + d[0][0]);
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
4098 sprite_ref[0][1]= (a>>1)*(2*vop_ref[0][1] + d[0][1]);
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
4099 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
4100 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
4101 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
4102 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
4103 }
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
4104 /* 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
4105 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
4106
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
4107 // 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
4108 // 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
4109 // 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
4110 // 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
4111 virtual_ref[0][0]= 16*(vop_ref[0][0] + w2)
359
df0736462b9f move ABS() to common.h
michaelni
parents: 358
diff changeset
4112 + 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
4113 virtual_ref[0][1]= 16*vop_ref[0][1]
359
df0736462b9f move ABS() to common.h
michaelni
parents: 358
diff changeset
4114 + 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
4115 virtual_ref[1][0]= 16*vop_ref[0][0]
359
df0736462b9f move ABS() to common.h
michaelni
parents: 358
diff changeset
4116 + 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
4117 virtual_ref[1][1]= 16*(vop_ref[0][1] + h2)
359
df0736462b9f move ABS() to common.h
michaelni
parents: 358
diff changeset
4118 + 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
4119
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
4120 switch(s->num_sprite_warping_points)
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
4121 {
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
4122 case 0:
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
4123 s->sprite_offset[0][0]= 0;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
4124 s->sprite_offset[0][1]= 0;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
4125 s->sprite_offset[1][0]= 0;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
4126 s->sprite_offset[1][1]= 0;
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4127 s->sprite_delta[0][0]= a;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4128 s->sprite_delta[0][1]= 0;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4129 s->sprite_delta[1][0]= 0;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4130 s->sprite_delta[1][1]= a;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4131 s->sprite_shift[0]= 0;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4132 s->sprite_shift[1]= 0;
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
4133 break;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
4134 case 1: //GMC only
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
4135 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
4136 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
4137 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
4138 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
4139 s->sprite_delta[0][0]= a;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4140 s->sprite_delta[0][1]= 0;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4141 s->sprite_delta[1][0]= 0;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4142 s->sprite_delta[1][1]= a;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4143 s->sprite_shift[0]= 0;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4144 s->sprite_shift[1]= 0;
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
4145 break;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
4146 case 2:
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
4147 s->sprite_offset[0][0]= (sprite_ref[0][0]<<(alpha+rho))
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4148 + (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][0])
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4149 + ( r*sprite_ref[0][1] - virtual_ref[0][1])*(-vop_ref[0][1])
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4150 + (1<<(alpha+rho-1));
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
4151 s->sprite_offset[0][1]= (sprite_ref[0][1]<<(alpha+rho))
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4152 + (-r*sprite_ref[0][1] + virtual_ref[0][1])*(-vop_ref[0][0])
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4153 + (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][1])
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4154 + (1<<(alpha+rho-1));
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4155 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
4156 +( 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
4157 +2*w2*r*sprite_ref[0][0]
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4158 - 16*w2
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4159 + (1<<(alpha+rho+1)));
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4160 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
4161 +(-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
4162 +2*w2*r*sprite_ref[0][1]
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4163 - 16*w2
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4164 + (1<<(alpha+rho+1)));
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4165 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
4166 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
4167 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
4168 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
4169
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4170 s->sprite_shift[0]= alpha+rho;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4171 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
4172 break;
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4173 case 3:
847
f3c369b8ddca reversing header game
michaelni
parents: 821
diff changeset
4174 min_ab= FFMIN(alpha, beta);
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4175 w3= w2>>min_ab;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4176 h3= h2>>min_ab;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4177 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
4178 + (-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
4179 + (-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
4180 + (1<<(alpha+beta+rho-min_ab-1));
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4181 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
4182 + (-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
4183 + (-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
4184 + (1<<(alpha+beta+rho-min_ab-1));
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4185 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
4186 + (-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
4187 + 2*w2*h3*r*sprite_ref[0][0]
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4188 - 16*w2*h3
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4189 + (1<<(alpha+beta+rho-min_ab+1));
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4190 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
4191 + (-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
4192 + 2*w2*h3*r*sprite_ref[0][1]
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4193 - 16*w2*h3
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4194 + (1<<(alpha+beta+rho-min_ab+1));
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4195 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
4196 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
4197 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
4198 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
4199
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4200 s->sprite_shift[0]= alpha + beta + rho - min_ab;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4201 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
4202 break;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
4203 }
255
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
4204 /* try to simplify the situation */
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4205 if( s->sprite_delta[0][0] == a<<s->sprite_shift[0]
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4206 && s->sprite_delta[0][1] == 0
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4207 && s->sprite_delta[1][0] == 0
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4208 && s->sprite_delta[1][1] == a<<s->sprite_shift[0])
255
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
4209 {
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4210 s->sprite_offset[0][0]>>=s->sprite_shift[0];
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4211 s->sprite_offset[0][1]>>=s->sprite_shift[0];
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4212 s->sprite_offset[1][0]>>=s->sprite_shift[1];
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4213 s->sprite_offset[1][1]>>=s->sprite_shift[1];
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4214 s->sprite_delta[0][0]= a;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4215 s->sprite_delta[0][1]= 0;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4216 s->sprite_delta[1][0]= 0;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4217 s->sprite_delta[1][1]= a;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4218 s->sprite_shift[0]= 0;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4219 s->sprite_shift[1]= 0;
255
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
4220 s->real_sprite_warping_points=1;
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
4221 }
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4222 else{
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4223 int shift_y= 16 - s->sprite_shift[0];
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4224 int shift_c= 16 - s->sprite_shift[1];
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4225 //printf("shifts %d %d\n", shift_y, shift_c);
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4226 for(i=0; i<2; i++){
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4227 s->sprite_offset[0][i]<<= shift_y;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4228 s->sprite_offset[1][i]<<= shift_c;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4229 s->sprite_delta[0][i]<<= shift_y;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4230 s->sprite_delta[1][i]<<= shift_y;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4231 s->sprite_shift[i]= 16;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4232 }
255
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
4233 s->real_sprite_warping_points= s->num_sprite_warping_points;
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4234 }
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4235 #if 0
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4236 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
4237 vop_ref[0][0], vop_ref[0][1],
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4238 vop_ref[1][0], vop_ref[1][1],
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4239 vop_ref[2][0], vop_ref[2][1],
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4240 sprite_ref[0][0], sprite_ref[0][1],
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4241 sprite_ref[1][0], sprite_ref[1][1],
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4242 sprite_ref[2][0], sprite_ref[2][1],
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4243 virtual_ref[0][0], virtual_ref[0][1],
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4244 virtual_ref[1][0], virtual_ref[1][1]
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4245 );
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4246
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4247 printf("offset: %d:%d , delta: %d %d %d %d, shift %d\n",
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4248 s->sprite_offset[0][0], s->sprite_offset[0][1],
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4249 s->sprite_delta[0][0], s->sprite_delta[0][1],
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4250 s->sprite_delta[1][0], s->sprite_delta[1][1],
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4251 s->sprite_shift[0]
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4252 );
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4253 #endif
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
4254 }
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
4255
942
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
4256 static int mpeg4_decode_gop_header(MpegEncContext * s, GetBitContext *gb){
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
4257 int hours, minutes, seconds;
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
4258
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
4259 hours= get_bits(gb, 5);
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
4260 minutes= get_bits(gb, 6);
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
4261 skip_bits1(gb);
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
4262 seconds= get_bits(gb, 6);
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
4263
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
4264 s->time_base= seconds + 60*(minutes + 60*hours);
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
4265
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
4266 skip_bits1(gb);
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
4267 skip_bits1(gb);
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
4268
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
4269 return 0;
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
4270 }
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
4271
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4272 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
4273 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
4274
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4275 /* vol header */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4276 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
4277 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
4278 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
4279 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
4280 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
4281 } else {
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4282 vo_ver_id = 1;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4283 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4284 //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
4285 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
4286 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
4287 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
4288 s->aspected_height = get_bits(gb, 8); // par_height
887
19f5b8b7c6d5 fixing aspect
michaelni
parents: 880
diff changeset
4289 }else{
19f5b8b7c6d5 fixing aspect
michaelni
parents: 880
diff changeset
4290 s->aspected_width = pixel_aspect[s->aspect_ratio_info][0];
19f5b8b7c6d5 fixing aspect
michaelni
parents: 880
diff changeset
4291 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
4292 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4293
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4294 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
4295 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
4296 if(chroma_format!=1){
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4297 printf("illegal chroma format\n");
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4298 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4299 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
4300 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
4301 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
4302 skip_bits1(gb); /* marker */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4303 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
4304 skip_bits1(gb); /* marker */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4305 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
4306 skip_bits1(gb); /* marker */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4307 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
4308 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
4309 skip_bits1(gb); /* marker */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4310 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
4311 skip_bits1(gb); /* marker */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4312 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4313 }else{
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4314 // 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
4315 if(s->picture_number==0)
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4316 s->low_delay=0;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4317 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4318
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4319 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
4320 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
4321 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
4322 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
4323 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
4324 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4325
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4326 skip_bits1(gb); /* marker */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4327
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4328 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
4329
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4330 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
4331 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
4332 s->time_increment_bits = 1;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4333 skip_bits1(gb); /* marker */
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 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
4336 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
4337 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4338
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4339 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
4340 if (s->shape == RECT_SHAPE) {
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4341 skip_bits1(gb); /* marker */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4342 width = get_bits(gb, 13);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4343 skip_bits1(gb); /* marker */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4344 height = get_bits(gb, 13);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4345 skip_bits1(gb); /* marker */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4346 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
4347 s->width = width;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4348 s->height = height;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4349 // 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
4350 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4351 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4352
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4353 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
4354 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
4355 if (vo_ver_id == 1) {
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4356 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
4357 } else {
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4358 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
4359 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4360 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
4361 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
4362 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
4363 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
4364 skip_bits1(gb); /* marker */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4365 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
4366 skip_bits1(gb); /* marker */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4367 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
4368 skip_bits1(gb); /* marker */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4369 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
4370 skip_bits1(gb); /* marker */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4371 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4372 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
4373 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
4374 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
4375 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
4376 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
4377 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4378 // 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
4379
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4380 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
4381 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
4382 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
4383 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
4384 } else {
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4385 s->quant_precision = 5;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4386 }
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4387
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4388 // 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
4389
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4390 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
4391 int i, j, v;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4392
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4393 /* load default matrixes */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4394 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
4395 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
4396 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
4397 s->intra_matrix[j]= v;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4398 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
4399
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4400 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
4401 s->inter_matrix[j]= v;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4402 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
4403 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4404
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4405 /* load custom intra matrix */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4406 if(get_bits1(gb)){
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4407 int last=0;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4408 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
4409 v= get_bits(gb, 8);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4410 if(v==0) break;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4411
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4412 last= v;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4413 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
4414 s->intra_matrix[j]= v;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4415 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
4416 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4417
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4418 /* replicate last value */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4419 for(; i<64; i++){
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4420 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
4421 s->intra_matrix[j]= v;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4422 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
4423 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4424 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4425
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4426 /* load custom non intra matrix */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4427 if(get_bits1(gb)){
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4428 int last=0;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4429 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
4430 v= get_bits(gb, 8);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4431 if(v==0) break;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4432
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4433 last= v;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4434 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
4435 s->inter_matrix[j]= v;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4436 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
4437 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4438
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4439 /* replicate last value */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4440 for(; i<64; i++){
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4441 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
4442 s->inter_matrix[j]= last;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4443 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
4444 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4445 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4446
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4447 // 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
4448 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4449
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4450 if(vo_ver_id != 1)
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4451 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
4452 else s->quarter_sample=0;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4453
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4454 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
4455
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4456 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
4457
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4458 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
4459 if(s->data_partitioning){
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4460 s->rvlc= get_bits1(gb);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4461 if(s->rvlc){
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4462 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
4463 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4464 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4465
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4466 if(vo_ver_id != 1) {
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4467 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
4468 if(s->new_pred){
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4469 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
4470 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
4471 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
4472 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4473 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
4474 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
4475 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4476 else{
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4477 s->new_pred=0;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4478 s->reduced_res_vop= 0;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4479 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4480
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4481 s->scalability= get_bits1(gb);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4482
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4483 if (s->scalability) {
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4484 GetBitContext bak= *gb;
751
cbe316f082bc warning fixes
michaelni
parents: 747
diff changeset
4485 int ref_layer_id;
cbe316f082bc warning fixes
michaelni
parents: 747
diff changeset
4486 int ref_layer_sampling_dir;
cbe316f082bc warning fixes
michaelni
parents: 747
diff changeset
4487 int h_sampling_factor_n;
cbe316f082bc warning fixes
michaelni
parents: 747
diff changeset
4488 int h_sampling_factor_m;
cbe316f082bc warning fixes
michaelni
parents: 747
diff changeset
4489 int v_sampling_factor_n;
cbe316f082bc warning fixes
michaelni
parents: 747
diff changeset
4490 int v_sampling_factor_m;
cbe316f082bc warning fixes
michaelni
parents: 747
diff changeset
4491
cbe316f082bc warning fixes
michaelni
parents: 747
diff changeset
4492 s->hierachy_type= get_bits1(gb);
cbe316f082bc warning fixes
michaelni
parents: 747
diff changeset
4493 ref_layer_id= get_bits(gb, 4);
cbe316f082bc warning fixes
michaelni
parents: 747
diff changeset
4494 ref_layer_sampling_dir= get_bits1(gb);
cbe316f082bc warning fixes
michaelni
parents: 747
diff changeset
4495 h_sampling_factor_n= get_bits(gb, 5);
cbe316f082bc warning fixes
michaelni
parents: 747
diff changeset
4496 h_sampling_factor_m= get_bits(gb, 5);
cbe316f082bc warning fixes
michaelni
parents: 747
diff changeset
4497 v_sampling_factor_n= get_bits(gb, 5);
cbe316f082bc warning fixes
michaelni
parents: 747
diff changeset
4498 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
4499 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
4500
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4501 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
4502 || 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
4503
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4504 // 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
4505 s->scalability=0;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4506
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4507 *gb= bak;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4508 }else
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4509 printf("scalability not supported\n");
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4510
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4511 // bin shape stuff FIXME
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4512 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4513 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4514 return 0;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4515 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4516
1034
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
4517 /**
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
4518 * decodes the user data stuff in the header.
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
4519 * allso inits divx/xvid/lavc_version/build
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
4520 */
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4521 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
4522 char buf[256];
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4523 int i;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4524 int e;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4525 int ver, build, ver2, ver3;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4526
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4527 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
4528 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
4529 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
4530 if(buf[i]==0) break;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4531 skip_bits(gb, 8);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4532 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4533 buf[255]=0;
761
7f4cc2f6d642 xvid qpel bug autodetect
michaelni
parents: 757
diff changeset
4534
7f4cc2f6d642 xvid qpel bug autodetect
michaelni
parents: 757
diff changeset
4535 /* divx detection */
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4536 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
4537 if(e!=2)
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4538 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
4539 if(e==2){
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4540 s->divx_version= ver;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4541 s->divx_build= build;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4542 if(s->picture_number==0){
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4543 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
4544 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4545 }
761
7f4cc2f6d642 xvid qpel bug autodetect
michaelni
parents: 757
diff changeset
4546
7f4cc2f6d642 xvid qpel bug autodetect
michaelni
parents: 757
diff changeset
4547 /* ffmpeg detection */
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4548 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
4549 if(e!=4)
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4550 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
4551 if(e!=4){
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4552 if(strcmp(buf, "ffmpeg")==0){
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4553 s->ffmpeg_version= 0x000406;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4554 s->lavc_build= 4600;
63
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
4555 }
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4556 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4557 if(e==4){
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4558 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
4559 s->lavc_build= build;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4560 if(s->picture_number==0)
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4561 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
4562 }
761
7f4cc2f6d642 xvid qpel bug autodetect
michaelni
parents: 757
diff changeset
4563
7f4cc2f6d642 xvid qpel bug autodetect
michaelni
parents: 757
diff changeset
4564 /* xvid detection */
7f4cc2f6d642 xvid qpel bug autodetect
michaelni
parents: 757
diff changeset
4565 e=sscanf(buf, "XviD%d", &build);
7f4cc2f6d642 xvid qpel bug autodetect
michaelni
parents: 757
diff changeset
4566 if(e==1){
7f4cc2f6d642 xvid qpel bug autodetect
michaelni
parents: 757
diff changeset
4567 s->xvid_build= build;
7f4cc2f6d642 xvid qpel bug autodetect
michaelni
parents: 757
diff changeset
4568 if(s->picture_number==0)
7f4cc2f6d642 xvid qpel bug autodetect
michaelni
parents: 757
diff changeset
4569 printf("This file was encoded with XviD build %d\n", build);
7f4cc2f6d642 xvid qpel bug autodetect
michaelni
parents: 757
diff changeset
4570 }
7f4cc2f6d642 xvid qpel bug autodetect
michaelni
parents: 757
diff changeset
4571
255
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
4572 //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
4573 return 0;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4574 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4575
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4576 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
4577 int time_incr, time_increment;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4578
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4579 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
4580 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
4581 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
4582 s->low_delay=0;
fdeec2834c79 there are divx5? encoded files without a userdata section but with b-frames :(
michaelni
parents: 364
diff changeset
4583 }
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4584
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
4585 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
4586 if(s->partitioned_frame)
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
4587 s->decode_mb= mpeg4_decode_partitioned_mb;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
4588 else
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
4589 s->decode_mb= ff_h263_decode_mb;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
4590
662
5a158f0d1981 fixing 1/0 if the headers are incomplete (like what M$ encoder generates)
michaelni
parents: 661
diff changeset
4591 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
4592 s->time_increment_resolution=1;
5a158f0d1981 fixing 1/0 if the headers are incomplete (like what M$ encoder generates)
michaelni
parents: 661
diff changeset
4593 // 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
4594 }
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
4595 time_incr=0;
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4596 while (get_bits1(gb) != 0)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4597 time_incr++;
986e461dc072 Initial revision
glantau
parents:
diff changeset
4598
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4599 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
4600 time_increment= get_bits(gb, s->time_increment_bits);
697
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
4601 //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
4602 if(s->pict_type!=B_TYPE){
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
4603 s->last_time_base= s->time_base;
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
4604 s->time_base+= time_incr;
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
4605 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
4606 if(s->workaround_bugs&FF_BUG_UMP4){
700
0fb4c66527e1 autodetect UMP4 (by adding a fourcc field to AVCodecContext)
michaelni
parents: 699
diff changeset
4607 if(s->time < s->last_non_b_time){
0fb4c66527e1 autodetect UMP4 (by adding a fourcc field to AVCodecContext)
michaelni
parents: 699
diff changeset
4608 // 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
4609 s->time_base++;
0fb4c66527e1 autodetect UMP4 (by adding a fourcc field to AVCodecContext)
michaelni
parents: 699
diff changeset
4610 s->time+= s->time_increment_resolution;
0fb4c66527e1 autodetect UMP4 (by adding a fourcc field to AVCodecContext)
michaelni
parents: 699
diff changeset
4611 }
664
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
4612 }
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
4613 s->pp_time= s->time - s->last_non_b_time;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
4614 s->last_non_b_time= s->time;
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
4615 }else{
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
4616 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
4617 s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
4618 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
4619 // printf("messed up order, seeking?, skiping current b frame\n");
e7e9d9901523 b-frame mpeg4 fix when seeking
michaelni
parents: 333
diff changeset
4620 return FRAME_SKIPED;
e7e9d9901523 b-frame mpeg4 fix when seeking
michaelni
parents: 333
diff changeset
4621 }
664
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
4622
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
4623 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
4624 if(s->t_frame==0) s->t_frame=1; // 1/0 protection
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
4625 //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
4626 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
4627 - 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
4628 s->pb_field_time= ( ROUNDED_DIV(s->time, s->t_frame)
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
4629 - ROUNDED_DIV(s->last_non_b_time - s->pp_time, s->t_frame))*2;
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
4630 }
654
850098147a3c export pts from stream if available
michaelni
parents: 648
diff changeset
4631
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
4632 s->current_picture.pts= s->time*1000LL*1000LL / s->time_increment_resolution;
942
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
4633 if(s->avctx->debug&FF_DEBUG_PTS)
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
4634 printf("MPEG4 PTS: %f\n", s->current_picture.pts/(1000.0*1000.0));
654
850098147a3c export pts from stream if available
michaelni
parents: 648
diff changeset
4635
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4636 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
4637 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
4638 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
4639 if(get_bits1(gb)) break;
264
28c5c62b1c4c support decoding (with mplayer) of 3 .mp4 files from mphq
michaelni
parents: 263
diff changeset
4640 }
28c5c62b1c4c support decoding (with mplayer) of 3 .mp4 files from mphq
michaelni
parents: 263
diff changeset
4641 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
4642 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4643 /* vop coded */
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4644 if (get_bits1(gb) != 1){
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4645 printf("vop not coded\n");
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4646 return FRAME_SKIPED;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4647 }
664
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
4648 //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
4649 //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
4650 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
4651 || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE))) {
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4652 /* 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
4653 s->no_rounding = get_bits1(gb);
63
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
4654 } else {
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
4655 s->no_rounding = 0;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4656 }
253
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
4657 //FIXME reduced res stuff
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
4658
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
4659 if (s->shape != RECT_SHAPE) {
63
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
4660 if (s->vol_sprite_usage != 1 || s->pict_type != I_TYPE) {
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
4661 int width, height, hor_spat_ref, ver_spat_ref;
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
4662
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4663 width = get_bits(gb, 13);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4664 skip_bits1(gb); /* marker */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4665 height = get_bits(gb, 13);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4666 skip_bits1(gb); /* marker */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4667 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
4668 skip_bits1(gb); /* marker */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4669 ver_spat_ref = get_bits(gb, 13); /* ver_spat_ref */
63
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
4670 }
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4671 skip_bits1(gb); /* change_CR_disable */
63
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
4672
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4673 if (get_bits1(gb) != 0) {
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4674 skip_bits(gb, 8); /* constant_alpha_value */
63
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
4675 }
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
4676 }
253
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
4677 //FIXME complexity estimation stuff
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
4678
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
4679 if (s->shape != BIN_ONLY_SHAPE) {
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
4680 int t;
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4681 t=get_bits(gb, 3); /* intra dc VLC threshold */
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
4682 //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
4683 if(!s->progressive_sequence){
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4684 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
4685 s->alternate_scan= get_bits1(gb);
661
a0901e38c564 fixing interlaced mpeg4 decoding
michaelni
parents: 660
diff changeset
4686 }else
a0901e38c564 fixing interlaced mpeg4 decoding
michaelni
parents: 660
diff changeset
4687 s->alternate_scan= 0;
253
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
4688 }
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
4689
718
16dab8296293 fixing custom quantizer matrix decoding
michaelni
parents: 706
diff changeset
4690 if(s->alternate_scan){
16dab8296293 fixing custom quantizer matrix decoding
michaelni
parents: 706
diff changeset
4691 ff_init_scantable(s, &s->inter_scantable , ff_alternate_vertical_scan);
16dab8296293 fixing custom quantizer matrix decoding
michaelni
parents: 706
diff changeset
4692 ff_init_scantable(s, &s->intra_scantable , ff_alternate_vertical_scan);
16dab8296293 fixing custom quantizer matrix decoding
michaelni
parents: 706
diff changeset
4693 ff_init_scantable(s, &s->intra_h_scantable, ff_alternate_vertical_scan);
16dab8296293 fixing custom quantizer matrix decoding
michaelni
parents: 706
diff changeset
4694 ff_init_scantable(s, &s->intra_v_scantable, ff_alternate_vertical_scan);
16dab8296293 fixing custom quantizer matrix decoding
michaelni
parents: 706
diff changeset
4695 } else{
16dab8296293 fixing custom quantizer matrix decoding
michaelni
parents: 706
diff changeset
4696 ff_init_scantable(s, &s->inter_scantable , ff_zigzag_direct);
16dab8296293 fixing custom quantizer matrix decoding
michaelni
parents: 706
diff changeset
4697 ff_init_scantable(s, &s->intra_scantable , ff_zigzag_direct);
16dab8296293 fixing custom quantizer matrix decoding
michaelni
parents: 706
diff changeset
4698 ff_init_scantable(s, &s->intra_h_scantable, ff_alternate_horizontal_scan);
16dab8296293 fixing custom quantizer matrix decoding
michaelni
parents: 706
diff changeset
4699 ff_init_scantable(s, &s->intra_v_scantable, ff_alternate_vertical_scan);
16dab8296293 fixing custom quantizer matrix decoding
michaelni
parents: 706
diff changeset
4700 }
16dab8296293 fixing custom quantizer matrix decoding
michaelni
parents: 706
diff changeset
4701
253
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
4702 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
4703 mpeg4_decode_sprite_trajectory(s);
253
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
4704 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
4705 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
4706 }
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
4707
253
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
4708 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
4709 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
4710 if(s->qscale==0){
28c5c62b1c4c support decoding (with mplayer) of 3 .mp4 files from mphq
michaelni
parents: 263
diff changeset
4711 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
4712 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
4713 }
63
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
4714
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
4715 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
4716 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
4717 if(s->f_code==0){
28c5c62b1c4c support decoding (with mplayer) of 3 .mp4 files from mphq
michaelni
parents: 263
diff changeset
4718 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
4719 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
4720 }
582
5132a4ee50cd different edge positions fixed with edge emu / dr1
michaelni
parents: 575
diff changeset
4721 }else
5132a4ee50cd different edge positions fixed with edge emu / dr1
michaelni
parents: 575
diff changeset
4722 s->f_code=1;
5132a4ee50cd different edge positions fixed with edge emu / dr1
michaelni
parents: 575
diff changeset
4723
253
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
4724 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
4725 s->b_code = get_bits(gb, 3);
582
5132a4ee50cd different edge positions fixed with edge emu / dr1
michaelni
parents: 575
diff changeset
4726 }else
5132a4ee50cd different edge positions fixed with edge emu / dr1
michaelni
parents: 575
diff changeset
4727 s->b_code=1;
906
bbe0c99231a7 specific debug output support
michaelni
parents: 905
diff changeset
4728
bbe0c99231a7 specific debug output support
michaelni
parents: 905
diff changeset
4729 if(s->avctx->debug&FF_DEBUG_PICT_INFO){
930
6bcb214d6a17 more debug output
michaelni
parents: 923
diff changeset
4730 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
4731 s->qscale, s->f_code, s->b_code,
bbe0c99231a7 specific debug output support
michaelni
parents: 905
diff changeset
4732 s->pict_type == I_TYPE ? "I" : (s->pict_type == P_TYPE ? "P" : (s->pict_type == B_TYPE ? "B" : "S")),
1025
1f9afd8b9131 GetBitContext.size is allways multiplied by 8 -> use size_in_bits to avoid useless *8 in a few inner loops
michaelni
parents: 1013
diff changeset
4733 gb->size_in_bits,s->progressive_sequence, s->alternate_scan, s->top_field_first,
930
6bcb214d6a17 more debug output
michaelni
parents: 923
diff changeset
4734 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
4735 s->sprite_warping_accuracy);
bbe0c99231a7 specific debug output support
michaelni
parents: 905
diff changeset
4736 }
bbe0c99231a7 specific debug output support
michaelni
parents: 905
diff changeset
4737
253
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
4738 if(!s->scalability){
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
4739 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
4740 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
4741 }
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
4742 }else{
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
4743 if(s->enhancement_type){
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4744 int load_backward_shape= get_bits1(gb);
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
4745 if(load_backward_shape){
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
4746 printf("load backward shape isnt supported\n");
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
4747 }
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
4748 }
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4749 skip_bits(gb, 2); //ref_select_code
63
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
4750 }
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
4751 }
346
c2f789fe4945 detecting xvid/divx4/opendivx and set low_delay flag
michaelni
parents: 344
diff changeset
4752 /* 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
4753 // 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
4754 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
4755 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
4756 s->low_delay=1;
c2f789fe4945 detecting xvid/divx4/opendivx and set low_delay flag
michaelni
parents: 344
diff changeset
4757 }
c2f789fe4945 detecting xvid/divx4/opendivx and set low_delay flag
michaelni
parents: 344
diff changeset
4758
255
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
4759 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
4760
498
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
4761 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
4762 s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
4763
582
5132a4ee50cd different edge positions fixed with edge emu / dr1
michaelni
parents: 575
diff changeset
4764 if(s->divx_version==0 || s->divx_version < 500){
5132a4ee50cd different edge positions fixed with edge emu / dr1
michaelni
parents: 575
diff changeset
4765 s->h_edge_pos= s->width;
5132a4ee50cd different edge positions fixed with edge emu / dr1
michaelni
parents: 575
diff changeset
4766 s->v_edge_pos= s->height;
5132a4ee50cd different edge positions fixed with edge emu / dr1
michaelni
parents: 575
diff changeset
4767 }
63
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
4768 return 0;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4769 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
4770
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4771 /**
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4772 * decode mpeg4 headers
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4773 * @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
4774 * 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
4775 * 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
4776 */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4777 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
4778 {
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4779 int startcode, v;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4780
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4781 /* search next start code */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4782 align_get_bits(gb);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4783 startcode = 0xff;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4784 for(;;) {
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4785 v = get_bits(gb, 8);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4786 startcode = ((startcode << 8) | v) & 0xffffffff;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4787
1025
1f9afd8b9131 GetBitContext.size is allways multiplied by 8 -> use size_in_bits to avoid useless *8 in a few inner loops
michaelni
parents: 1013
diff changeset
4788 if(get_bits_count(gb) >= gb->size_in_bits){
1f9afd8b9131 GetBitContext.size is allways multiplied by 8 -> use size_in_bits to avoid useless *8 in a few inner loops
michaelni
parents: 1013
diff changeset
4789 if(gb->size_in_bits==8 && s->divx_version){
1f9afd8b9131 GetBitContext.size is allways multiplied by 8 -> use size_in_bits to avoid useless *8 in a few inner loops
michaelni
parents: 1013
diff changeset
4790 printf("frame skip %d\n", gb->size_in_bits);
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4791 return FRAME_SKIPED; //divx bug
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4792 }else
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4793 return -1; //end of stream
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4794 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4795
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4796 if((startcode&0xFFFFFF00) != 0x100)
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4797 continue; //no startcode
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4798
942
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
4799 if(s->avctx->debug&FF_DEBUG_STARTCODE){
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
4800 printf("startcode: %3X ", startcode);
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
4801 if (startcode<=0x11F) printf("Video Object Start");
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
4802 else if(startcode<=0x12F) printf("Video Object Layer Start");
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
4803 else if(startcode<=0x13F) printf("Reserved");
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
4804 else if(startcode<=0x15F) printf("FGS bp start");
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
4805 else if(startcode<=0x1AF) printf("Reserved");
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
4806 else if(startcode==0x1B0) printf("Visual Object Seq Start");
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
4807 else if(startcode==0x1B1) printf("Visual Object Seq End");
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
4808 else if(startcode==0x1B2) printf("User Data");
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
4809 else if(startcode==0x1B3) printf("Group of VOP start");
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
4810 else if(startcode==0x1B4) printf("Video Session Error");
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
4811 else if(startcode==0x1B5) printf("Visual Object Start");
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
4812 else if(startcode==0x1B6) printf("Video Object Plane start");
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
4813 else if(startcode==0x1B7) printf("slice start");
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
4814 else if(startcode==0x1B8) printf("extension start");
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
4815 else if(startcode==0x1B9) printf("fgs start");
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
4816 else if(startcode==0x1BA) printf("FBA Object start");
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
4817 else if(startcode==0x1BB) printf("FBA Object Plane start");
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
4818 else if(startcode==0x1BC) printf("Mesh Object start");
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
4819 else if(startcode==0x1BD) printf("Mesh Object Plane start");
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
4820 else if(startcode==0x1BE) printf("Still Textutre Object start");
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
4821 else if(startcode==0x1BF) printf("Textutre Spatial Layer start");
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
4822 else if(startcode==0x1C0) printf("Textutre SNR Layer start");
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
4823 else if(startcode==0x1C1) printf("Textutre Tile start");
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
4824 else if(startcode==0x1C2) printf("Textutre Shape Layer start");
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
4825 else if(startcode==0x1C3) printf("stuffing start");
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
4826 else if(startcode<=0x1C5) printf("reserved");
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
4827 else if(startcode<=0x1FF) printf("System start");
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
4828 printf(" at %d\n", get_bits_count(gb));
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
4829 }
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
4830
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4831 switch(startcode){
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4832 case 0x120:
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4833 decode_vol_header(s, gb);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4834 break;
942
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
4835 case USER_DATA_STARTCODE:
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4836 decode_user_data(s, gb);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4837 break;
942
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
4838 case GOP_STARTCODE:
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
4839 mpeg4_decode_gop_header(s, gb);
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
4840 break;
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
4841 case VOP_STARTCODE:
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4842 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
4843 default:
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4844 break;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4845 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4846
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4847 align_get_bits(gb);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4848 startcode = 0xff;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4849 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4850 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4851
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4852 /* don't understand why they choose a different header ! */
986e461dc072 Initial revision
glantau
parents:
diff changeset
4853 int intel_h263_decode_picture_header(MpegEncContext *s)
986e461dc072 Initial revision
glantau
parents:
diff changeset
4854 {
986e461dc072 Initial revision
glantau
parents:
diff changeset
4855 int format;
986e461dc072 Initial revision
glantau
parents:
diff changeset
4856
986e461dc072 Initial revision
glantau
parents:
diff changeset
4857 /* picture header */
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4858 if (get_bits(&s->gb, 22) != 0x20) {
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4859 fprintf(stderr, "Bad picture start code\n");
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4860 return -1;
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4861 }
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4862 s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4863
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4864 if (get_bits1(&s->gb) != 1) {
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4865 fprintf(stderr, "Bad marker\n");
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4866 return -1; /* marker */
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4867 }
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4868 if (get_bits1(&s->gb) != 0) {
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4869 fprintf(stderr, "Bad H263 id\n");
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4870 return -1; /* h263 id */
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4871 }
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
4872 skip_bits1(&s->gb); /* split screen off */
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
4873 skip_bits1(&s->gb); /* camera off */
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
4874 skip_bits1(&s->gb); /* freeze picture release off */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4875
986e461dc072 Initial revision
glantau
parents:
diff changeset
4876 format = get_bits(&s->gb, 3);
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4877 if (format != 7) {
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4878 fprintf(stderr, "Intel H263 free format not supported\n");
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4879 return -1;
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4880 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4881 s->h263_plus = 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
4882
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
4883 s->pict_type = I_TYPE + get_bits1(&s->gb);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4884
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
4885 s->unrestricted_mv = get_bits1(&s->gb);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4886 s->h263_long_vectors = s->unrestricted_mv;
986e461dc072 Initial revision
glantau
parents:
diff changeset
4887
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4888 if (get_bits1(&s->gb) != 0) {
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4889 fprintf(stderr, "SAC not supported\n");
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4890 return -1; /* SAC: off */
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4891 }
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4892 if (get_bits1(&s->gb) != 0) {
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4893 fprintf(stderr, "Advanced Prediction Mode not supported\n");
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4894 return -1; /* advanced prediction mode: off */
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4895 }
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4896 if (get_bits1(&s->gb) != 0) {
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4897 fprintf(stderr, "PB frame mode no supported\n");
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4898 return -1; /* PB frame mode */
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4899 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4900
986e461dc072 Initial revision
glantau
parents:
diff changeset
4901 /* skip unknown header garbage */
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
4902 skip_bits(&s->gb, 41);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4903
986e461dc072 Initial revision
glantau
parents:
diff changeset
4904 s->qscale = get_bits(&s->gb, 5);
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
4905 skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4906
986e461dc072 Initial revision
glantau
parents:
diff changeset
4907 /* PEI */
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
4908 while (get_bits1(&s->gb) != 0) {
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
4909 skip_bits(&s->gb, 8);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4910 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
4911 s->f_code = 1;
770
d1770a34e4f6 segfault fix patch by (Juergen Keil <jk at tools dot de>)
michaelni
parents: 766
diff changeset
4912
d1770a34e4f6 segfault fix patch by (Juergen Keil <jk at tools dot de>)
michaelni
parents: 766
diff changeset
4913 s->y_dc_scale_table=
d1770a34e4f6 segfault fix patch by (Juergen Keil <jk at tools dot de>)
michaelni
parents: 766
diff changeset
4914 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
4915
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4916 return 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
4917 }
144
cb5dabd00ba2 - Bug fix on inter MCBPC table for inter+q.
pulento
parents: 110
diff changeset
4918