annotate h263.c @ 1150:dde68a430ba9 libavcodec

user setable quantizer bias
author michaelni
date Sat, 22 Mar 2003 12:09:02 +0000
parents 79e8ed620b17
children 8c15d82c1893
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
1106
1e39f273ecd6 per file doxy
michaelni
parents: 1092
diff changeset
28 * h263/mpeg4 codec.
1034
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
29 */
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
30
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
31 //#define DEBUG
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
32 #include "common.h"
986e461dc072 Initial revision
glantau
parents:
diff changeset
33 #include "dsputil.h"
986e461dc072 Initial revision
glantau
parents:
diff changeset
34 #include "avcodec.h"
986e461dc072 Initial revision
glantau
parents:
diff changeset
35 #include "mpegvideo.h"
986e461dc072 Initial revision
glantau
parents:
diff changeset
36 #include "h263data.h"
986e461dc072 Initial revision
glantau
parents:
diff changeset
37 #include "mpeg4data.h"
986e461dc072 Initial revision
glantau
parents:
diff changeset
38
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
39 //#undef NDEBUG
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
40 //#include <assert.h>
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
41
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
42 #if 1
523
c7e4c8b9a3c4 warning fix patch by atmos
michaelni
parents: 498
diff changeset
43 #define PRINT_MB_TYPE(a) {}
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
44 #else
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
45 #define PRINT_MB_TYPE(a) printf(a)
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
46 #endif
359
df0736462b9f move ABS() to common.h
michaelni
parents: 358
diff changeset
47
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
48 #define INTRA_MCBPC_VLC_BITS 6
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
49 #define INTER_MCBPC_VLC_BITS 6
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
50 #define CBPY_VLC_BITS 6
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
51 #define MV_VLC_BITS 9
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
52 #define DC_VLC_BITS 9
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
53 #define SPRITE_TRAJ_VLC_BITS 6
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
54 #define MB_TYPE_B_VLC_BITS 4
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
55 #define TEX_VLC_BITS 9
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
56
815
78accc54493b put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents: 770
diff changeset
57 #ifdef CONFIG_ENCODERS
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
58 static void h263_encode_block(MpegEncContext * s, DCTELEM * block,
986e461dc072 Initial revision
glantau
parents:
diff changeset
59 int n);
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
60 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
61 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
62 static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block,
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
63 int n, int dc, uint8_t *scan_table,
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
64 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
65 #endif
78accc54493b put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents: 770
diff changeset
66
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
67 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
68 static int h263p_decode_umotion(MpegEncContext * s, int pred);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
69 static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
986e461dc072 Initial revision
glantau
parents:
diff changeset
70 int n, int coded);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
71 static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
72 static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
1132
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
73 int n, int coded, int intra, int rvlc);
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
74 static int h263_pred_dc(MpegEncContext * s, int n, uint16_t **dc_val_ptr);
1070
6da5ae9ee199 more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents: 1068
diff changeset
75 #ifdef CONFIG_ENCODERS
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);
1070
6da5ae9ee199 more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents: 1068
diff changeset
78 #endif //CONFIG_ENCODERS
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
79 static void mpeg4_decode_sprite_trajectory(MpegEncContext * s);
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
80 static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, uint16_t **dc_val_ptr, int *dir_ptr);
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
81
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
82 extern uint32_t inverse[256];
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
83
1070
6da5ae9ee199 more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents: 1068
diff changeset
84 #ifdef CONFIG_ENCODERS
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
85 static uint8_t uni_DCtab_lum_len[512];
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
86 static uint8_t uni_DCtab_chrom_len[512];
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
87 static uint16_t uni_DCtab_lum_bits[512];
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
88 static uint16_t 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
89
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
90 static uint16_t (*mv_penalty)[MAX_MV*2+1]= NULL;
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
91 static uint8_t fcode_tab[MAX_MV*2+1];
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
92 static uint8_t umv_fcode_tab[MAX_MV*2+1];
815
78accc54493b put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents: 770
diff changeset
93
945
463f7260b155 trellis quantization
michaelni
parents: 942
diff changeset
94 static uint32_t uni_mpeg4_intra_rl_bits[64*64*2*2];
463f7260b155 trellis quantization
michaelni
parents: 942
diff changeset
95 static uint8_t uni_mpeg4_intra_rl_len [64*64*2*2];
463f7260b155 trellis quantization
michaelni
parents: 942
diff changeset
96 static uint32_t uni_mpeg4_inter_rl_bits[64*64*2*2];
463f7260b155 trellis quantization
michaelni
parents: 942
diff changeset
97 static uint8_t uni_mpeg4_inter_rl_len [64*64*2*2];
463f7260b155 trellis quantization
michaelni
parents: 942
diff changeset
98 //#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
99 //#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run) + (level)*64)
945
463f7260b155 trellis quantization
michaelni
parents: 942
diff changeset
100 #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
101
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream 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 /* 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
103 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
104 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
105 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
106
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream 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 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
108 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
109 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
110 */
815
78accc54493b put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents: 770
diff changeset
111 #endif
78accc54493b put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents: 770
diff changeset
112
293
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
113
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
114 int h263_get_picture_format(int width, int height)
986e461dc072 Initial revision
glantau
parents:
diff changeset
115 {
986e461dc072 Initial revision
glantau
parents:
diff changeset
116 int format;
986e461dc072 Initial revision
glantau
parents:
diff changeset
117
986e461dc072 Initial revision
glantau
parents:
diff changeset
118 if (width == 128 && height == 96)
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
119 format = 1;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
120 else if (width == 176 && height == 144)
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
121 format = 2;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
122 else if (width == 352 && height == 288)
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
123 format = 3;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
124 else if (width == 704 && height == 576)
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
125 format = 4;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
126 else if (width == 1408 && height == 1152)
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
127 format = 5;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
128 else
986e461dc072 Initial revision
glantau
parents:
diff changeset
129 format = 7;
986e461dc072 Initial revision
glantau
parents:
diff changeset
130 return format;
986e461dc072 Initial revision
glantau
parents:
diff changeset
131 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
132
1070
6da5ae9ee199 more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents: 1068
diff changeset
133 #ifdef CONFIG_ENCODERS
6da5ae9ee199 more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents: 1068
diff changeset
134
887
19f5b8b7c6d5 fixing aspect
michaelni
parents: 880
diff changeset
135 static void float_aspect_to_info(MpegEncContext * s, float aspect){
19f5b8b7c6d5 fixing aspect
michaelni
parents: 880
diff changeset
136 int i;
19f5b8b7c6d5 fixing aspect
michaelni
parents: 880
diff changeset
137
19f5b8b7c6d5 fixing aspect
michaelni
parents: 880
diff changeset
138 aspect*= s->height/(double)s->width;
19f5b8b7c6d5 fixing aspect
michaelni
parents: 880
diff changeset
139 //printf("%f\n", aspect);
880
1c32039e7215 aspect ratio cleanup
michaelni
parents: 853
diff changeset
140
887
19f5b8b7c6d5 fixing aspect
michaelni
parents: 880
diff changeset
141 if(aspect==0) aspect= 1.0;
19f5b8b7c6d5 fixing aspect
michaelni
parents: 880
diff changeset
142
880
1c32039e7215 aspect ratio cleanup
michaelni
parents: 853
diff changeset
143 ff_float2fraction(&s->aspected_width, &s->aspected_height, aspect, 255);
887
19f5b8b7c6d5 fixing aspect
michaelni
parents: 880
diff changeset
144
19f5b8b7c6d5 fixing aspect
michaelni
parents: 880
diff changeset
145 //printf("%d %d\n", s->aspected_width, s->aspected_height);
19f5b8b7c6d5 fixing aspect
michaelni
parents: 880
diff changeset
146 for(i=1; i<6; i++){
19f5b8b7c6d5 fixing aspect
michaelni
parents: 880
diff changeset
147 if(s->aspected_width == pixel_aspect[i][0] && s->aspected_height== pixel_aspect[i][1]){
19f5b8b7c6d5 fixing aspect
michaelni
parents: 880
diff changeset
148 s->aspect_ratio_info=i;
19f5b8b7c6d5 fixing aspect
michaelni
parents: 880
diff changeset
149 return;
19f5b8b7c6d5 fixing aspect
michaelni
parents: 880
diff changeset
150 }
19f5b8b7c6d5 fixing aspect
michaelni
parents: 880
diff changeset
151 }
880
1c32039e7215 aspect ratio cleanup
michaelni
parents: 853
diff changeset
152
887
19f5b8b7c6d5 fixing aspect
michaelni
parents: 880
diff changeset
153 s->aspect_ratio_info= FF_ASPECT_EXTENDED;
880
1c32039e7215 aspect ratio cleanup
michaelni
parents: 853
diff changeset
154 }
1c32039e7215 aspect ratio cleanup
michaelni
parents: 853
diff changeset
155
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
156 void h263_encode_picture_header(MpegEncContext * s, int picture_number)
986e461dc072 Initial revision
glantau
parents:
diff changeset
157 {
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
158 int format;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
159
986e461dc072 Initial revision
glantau
parents:
diff changeset
160 align_put_bits(&s->pb);
231
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
161
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
162 /* 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
163 s->ptr_lastgob = pbBufPtr(&s->pb);
231
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
164 s->gob_number = 0;
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
165
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
166 put_bits(&s->pb, 22, 0x20); /* PSC */
1126
77ccf7fe3bd0 per context frame_rate_base, this should finally fix frame_rate related av sync issues
michaelni
parents: 1118
diff changeset
167 put_bits(&s->pb, 8, (((int64_t)s->picture_number * 30 * s->avctx->frame_rate_base) /
77ccf7fe3bd0 per context frame_rate_base, this should finally fix frame_rate related av sync issues
michaelni
parents: 1118
diff changeset
168 s->avctx->frame_rate) & 0xff);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
169
986e461dc072 Initial revision
glantau
parents:
diff changeset
170 put_bits(&s->pb, 1, 1); /* marker */
986e461dc072 Initial revision
glantau
parents:
diff changeset
171 put_bits(&s->pb, 1, 0); /* h263 id */
986e461dc072 Initial revision
glantau
parents:
diff changeset
172 put_bits(&s->pb, 1, 0); /* split screen off */
986e461dc072 Initial revision
glantau
parents:
diff changeset
173 put_bits(&s->pb, 1, 0); /* camera off */
986e461dc072 Initial revision
glantau
parents:
diff changeset
174 put_bits(&s->pb, 1, 0); /* freeze picture release off */
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
175
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
176 format = h263_get_picture_format(s->width, s->height);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
177 if (!s->h263_plus) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
178 /* H.263v1 */
986e461dc072 Initial revision
glantau
parents:
diff changeset
179 put_bits(&s->pb, 3, format);
986e461dc072 Initial revision
glantau
parents:
diff changeset
180 put_bits(&s->pb, 1, (s->pict_type == P_TYPE));
986e461dc072 Initial revision
glantau
parents:
diff changeset
181 /* By now UMV IS DISABLED ON H.263v1, since the restrictions
986e461dc072 Initial revision
glantau
parents:
diff changeset
182 of H.263v1 UMV implies to check the predicted MV after
986e461dc072 Initial revision
glantau
parents:
diff changeset
183 calculation of the current MB to see if we're on the limits */
986e461dc072 Initial revision
glantau
parents:
diff changeset
184 put_bits(&s->pb, 1, 0); /* unrestricted motion vector: off */
986e461dc072 Initial revision
glantau
parents:
diff changeset
185 put_bits(&s->pb, 1, 0); /* SAC: off */
986e461dc072 Initial revision
glantau
parents:
diff changeset
186 put_bits(&s->pb, 1, 0); /* advanced prediction mode: off */
986e461dc072 Initial revision
glantau
parents:
diff changeset
187 put_bits(&s->pb, 1, 0); /* not PB frame */
986e461dc072 Initial revision
glantau
parents:
diff changeset
188 put_bits(&s->pb, 5, s->qscale);
986e461dc072 Initial revision
glantau
parents:
diff changeset
189 put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */
986e461dc072 Initial revision
glantau
parents:
diff changeset
190 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
191 /* H.263v2 */
986e461dc072 Initial revision
glantau
parents:
diff changeset
192 /* H.263 Plus PTYPE */
986e461dc072 Initial revision
glantau
parents:
diff changeset
193 put_bits(&s->pb, 3, 7);
986e461dc072 Initial revision
glantau
parents:
diff changeset
194 put_bits(&s->pb,3,1); /* Update Full Extended PTYPE */
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
195 if (format == 7)
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
196 put_bits(&s->pb,3,6); /* Custom Source Format */
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
197 else
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
198 put_bits(&s->pb, 3, format);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
199
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
200 put_bits(&s->pb,1,0); /* Custom PCF: off */
1089
7e79a58954b1 h263(+) clenaup & bugfixes
michaelni
parents: 1070
diff changeset
201 s->umvplus = s->unrestricted_mv;
79
82e579c37bc3 Moved some H.263+ variables to MpegEncContext to be thread-safe.
pulento
parents: 78
diff changeset
202 put_bits(&s->pb, 1, s->umvplus); /* Unrestricted Motion Vector */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
203 put_bits(&s->pb,1,0); /* SAC: off */
986e461dc072 Initial revision
glantau
parents:
diff changeset
204 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
205 put_bits(&s->pb,1,s->h263_aic); /* Advanced Intra Coding */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
206 put_bits(&s->pb,1,0); /* Deblocking Filter: off */
986e461dc072 Initial revision
glantau
parents:
diff changeset
207 put_bits(&s->pb,1,0); /* Slice Structured: off */
986e461dc072 Initial revision
glantau
parents:
diff changeset
208 put_bits(&s->pb,1,0); /* Reference Picture Selection: off */
986e461dc072 Initial revision
glantau
parents:
diff changeset
209 put_bits(&s->pb,1,0); /* Independent Segment Decoding: off */
986e461dc072 Initial revision
glantau
parents:
diff changeset
210 put_bits(&s->pb,1,0); /* Alternative Inter VLC: off */
986e461dc072 Initial revision
glantau
parents:
diff changeset
211 put_bits(&s->pb,1,0); /* Modified Quantization: off */
986e461dc072 Initial revision
glantau
parents:
diff changeset
212 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
986e461dc072 Initial revision
glantau
parents:
diff changeset
213 put_bits(&s->pb,3,0); /* Reserved */
986e461dc072 Initial revision
glantau
parents:
diff changeset
214
986e461dc072 Initial revision
glantau
parents:
diff changeset
215 put_bits(&s->pb, 3, s->pict_type == P_TYPE);
986e461dc072 Initial revision
glantau
parents:
diff changeset
216
986e461dc072 Initial revision
glantau
parents:
diff changeset
217 put_bits(&s->pb,1,0); /* Reference Picture Resampling: off */
986e461dc072 Initial revision
glantau
parents:
diff changeset
218 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
219 put_bits(&s->pb,1,s->no_rounding); /* Rounding Type */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
220 put_bits(&s->pb,2,0); /* Reserved */
986e461dc072 Initial revision
glantau
parents:
diff changeset
221 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
986e461dc072 Initial revision
glantau
parents:
diff changeset
222
986e461dc072 Initial revision
glantau
parents:
diff changeset
223 /* This should be here if PLUSPTYPE */
986e461dc072 Initial revision
glantau
parents:
diff changeset
224 put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */
986e461dc072 Initial revision
glantau
parents:
diff changeset
225
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
226 if (format == 7) {
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
227 /* Custom Picture Format (CPFMT) */
887
19f5b8b7c6d5 fixing aspect
michaelni
parents: 880
diff changeset
228 float_aspect_to_info(s, s->avctx->aspect_ratio);
880
1c32039e7215 aspect ratio cleanup
michaelni
parents: 853
diff changeset
229
1c32039e7215 aspect ratio cleanup
michaelni
parents: 853
diff changeset
230 put_bits(&s->pb,4,s->aspect_ratio_info);
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
231 put_bits(&s->pb,9,(s->width >> 2) - 1);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
232 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
233 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
234 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
235 {
b4bddbde44f3 aspect (ext. par too) support for h263 and mpeg4 (inc. build becouse of new vars)
al3x
parents: 667
diff changeset
236 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
237 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
238 }
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
239 }
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
240
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
241 /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
79
82e579c37bc3 Moved some H.263+ variables to MpegEncContext to be thread-safe.
pulento
parents: 78
diff changeset
242 if (s->umvplus)
1089
7e79a58954b1 h263(+) clenaup & bugfixes
michaelni
parents: 1070
diff changeset
243 // put_bits(&s->pb,1,1); /* Limited according tables of Annex D */
7e79a58954b1 h263(+) clenaup & bugfixes
michaelni
parents: 1070
diff changeset
244 put_bits(&s->pb,2,1); /* unlimited */
7e79a58954b1 h263(+) clenaup & bugfixes
michaelni
parents: 1070
diff changeset
245
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
246 put_bits(&s->pb, 5, s->qscale);
986e461dc072 Initial revision
glantau
parents:
diff changeset
247 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
248
986e461dc072 Initial revision
glantau
parents:
diff changeset
249 put_bits(&s->pb, 1, 0); /* no PEI */
498
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
250
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
251 if(s->h263_aic){
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
252 s->y_dc_scale_table=
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
253 s->c_dc_scale_table= h263_aic_dc_scale_table;
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
254 }else{
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
255 s->y_dc_scale_table=
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
256 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
257 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
258 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
259
766
8d36b35a7e6e slice encoding cleanup
michaelni
parents: 761
diff changeset
260 /**
8d36b35a7e6e slice encoding cleanup
michaelni
parents: 761
diff changeset
261 * Encodes a group of blocks header.
8d36b35a7e6e slice encoding cleanup
michaelni
parents: 761
diff changeset
262 */
162
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
263 int h263_encode_gob_header(MpegEncContext * s, int mb_line)
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
264 {
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
265 align_put_bits(&s->pb);
231
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
266 flush_put_bits(&s->pb);
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
267 /* Call the RTP callback to send the last GOB */
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
268 if (s->rtp_callback) {
766
8d36b35a7e6e slice encoding cleanup
michaelni
parents: 761
diff changeset
269 int pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;
231
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
270 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
271 }
162
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
272 put_bits(&s->pb, 17, 1); /* GBSC */
231
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
273 s->gob_number = mb_line / s->gob_index;
162
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
274 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
275 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
276 put_bits(&s->pb, 5, s->qscale); /* GQUANT */
231
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
277 //fprintf(stderr,"\nGOB: %2d size: %d", s->gob_number - 1, pdif);
766
8d36b35a7e6e slice encoding cleanup
michaelni
parents: 761
diff changeset
278 return 0;
162
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
279 }
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
280
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
281 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
282 {
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
283 int score0=0, score1=0;
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
284 int i, n;
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
285 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
286
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
287 for(n=0; n<6; n++){
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
288 int16_t *ac_val, *ac_val1;
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
289
266
252444e5259b optimization
michaelni
parents: 265
diff changeset
290 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
291 ac_val1= ac_val;
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
292 if(dir[n]){
692
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
293 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
294 /* top prediction */
266
252444e5259b optimization
michaelni
parents: 265
diff changeset
295 ac_val-= s->block_wrap[n]*16;
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
296 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
297 /* same qscale */
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
298 for(i=1; i<8; i++){
1092
f59c3f66363b MpegEncContext.(i)dct_* -> DspContext.(i)dct_*
michaelni
parents: 1090
diff changeset
299 const int level= block[n][s->dsp.idct_permutation[i ]];
692
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
300 score0+= ABS(level);
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
301 score1+= ABS(level - ac_val[i+8]);
1092
f59c3f66363b MpegEncContext.(i)dct_* -> DspContext.(i)dct_*
michaelni
parents: 1090
diff changeset
302 ac_val1[i ]= block[n][s->dsp.idct_permutation[i<<3]];
692
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
303 ac_val1[i+8]= level;
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
304 }
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
305 }else{
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
306 /* different qscale, we must rescale */
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
307 for(i=1; i<8; i++){
1092
f59c3f66363b MpegEncContext.(i)dct_* -> DspContext.(i)dct_*
michaelni
parents: 1090
diff changeset
308 const int level= block[n][s->dsp.idct_permutation[i ]];
692
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
309 score0+= ABS(level);
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
310 score1+= ABS(level - ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale));
1092
f59c3f66363b MpegEncContext.(i)dct_* -> DspContext.(i)dct_*
michaelni
parents: 1090
diff changeset
311 ac_val1[i ]= block[n][s->dsp.idct_permutation[i<<3]];
692
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
312 ac_val1[i+8]= level;
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
313 }
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
314 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
315 }else{
692
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
316 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
317 /* left prediction */
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
318 ac_val-= 16;
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
319 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
320 /* same qscale */
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
321 for(i=1; i<8; i++){
1092
f59c3f66363b MpegEncContext.(i)dct_* -> DspContext.(i)dct_*
michaelni
parents: 1090
diff changeset
322 const int level= block[n][s->dsp.idct_permutation[i<<3]];
692
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
323 score0+= ABS(level);
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
324 score1+= ABS(level - ac_val[i]);
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
325 ac_val1[i ]= level;
1092
f59c3f66363b MpegEncContext.(i)dct_* -> DspContext.(i)dct_*
michaelni
parents: 1090
diff changeset
326 ac_val1[i+8]= block[n][s->dsp.idct_permutation[i ]];
692
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
327 }
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
328 }else{
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
329 /* different qscale, we must rescale */
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
330 for(i=1; i<8; i++){
1092
f59c3f66363b MpegEncContext.(i)dct_* -> DspContext.(i)dct_*
michaelni
parents: 1090
diff changeset
331 const int level= block[n][s->dsp.idct_permutation[i<<3]];
692
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
332 score0+= ABS(level);
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
333 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
334 ac_val1[i ]= level;
1092
f59c3f66363b MpegEncContext.(i)dct_* -> DspContext.(i)dct_*
michaelni
parents: 1090
diff changeset
335 ac_val1[i+8]= block[n][s->dsp.idct_permutation[i ]];
692
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
336 }
265
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 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
339 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
340
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
341 return score0 > score1 ? 1 : 0;
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
342 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
343
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
344 /**
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
345 * 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
346 */
695
3525da287ee2 adaptive quantization for h263
michaelni
parents: 692
diff changeset
347 void ff_clean_h263_qscales(MpegEncContext *s){
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
348 int i;
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
349 int8_t * const qscale_table= s->current_picture.qscale_table;
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
350
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
351 for(i=1; i<s->mb_num; i++){
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
352 if(qscale_table[i] - qscale_table[i-1] >2)
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
353 qscale_table[i]= qscale_table[i-1]+2;
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
354 }
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
355 for(i=s->mb_num-2; i>=0; i--){
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
356 if(qscale_table[i] - qscale_table[i+1] >2)
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
357 qscale_table[i]= qscale_table[i+1]+2;
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
358 }
695
3525da287ee2 adaptive quantization for h263
michaelni
parents: 692
diff changeset
359 }
3525da287ee2 adaptive quantization for h263
michaelni
parents: 692
diff changeset
360
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
361 /**
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
362 * 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
363 */
695
3525da287ee2 adaptive quantization for h263
michaelni
parents: 692
diff changeset
364 void ff_clean_mpeg4_qscales(MpegEncContext *s){
3525da287ee2 adaptive quantization for h263
michaelni
parents: 692
diff changeset
365 int i;
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
366 int8_t * const qscale_table= s->current_picture.qscale_table;
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
367
695
3525da287ee2 adaptive quantization for h263
michaelni
parents: 692
diff changeset
368 ff_clean_h263_qscales(s);
690
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 for(i=1; i<s->mb_num; i++){
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
371 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
372 s->mb_type[i]&= ~MB_TYPE_INTER4V;
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
373 s->mb_type[i]|= MB_TYPE_INTER;
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
374 }
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
375 }
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
376
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
377 if(s->pict_type== B_TYPE){
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
378 int odd=0;
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
379 /* 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
380 for the actual adaptive quantization */
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
381
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
382 for(i=0; i<s->mb_num; i++){
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
383 odd += qscale_table[i]&1;
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
384 }
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
385
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
386 if(2*odd > s->mb_num) odd=1;
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
387 else odd=0;
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
388
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
389 for(i=0; i<s->mb_num; i++){
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
390 if((qscale_table[i]&1) != odd)
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
391 qscale_table[i]++;
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
392 if(qscale_table[i] > 31)
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
393 qscale_table[i]= 31;
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
394 }
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 for(i=1; i<s->mb_num; i++){
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
397 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
398 s->mb_type[i]&= ~MB_TYPE_DIRECT;
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
399 s->mb_type[i]|= MB_TYPE_BIDIR;
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
400 }
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
401 }
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
402 }
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
403 }
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
404
1070
6da5ae9ee199 more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents: 1068
diff changeset
405 #endif //CONFIG_ENCODERS
6da5ae9ee199 more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents: 1068
diff changeset
406
936
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
407 void ff_mpeg4_set_direct_mv(MpegEncContext *s, int mx, int my){
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
408 const int mb_index= s->mb_x + s->mb_y*s->mb_width;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
409 int xy= s->block_index[0];
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
410 uint16_t time_pp= s->pp_time;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
411 uint16_t time_pb= s->pb_time;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
412 int i;
1053
f07fd48c23d4 direct blocksize in bframes fix (might fix qpel+bframe bug)
michaelni
parents: 1042
diff changeset
413
936
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
414 //FIXME avoid divides
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
415 switch(s->co_located_type_table[mb_index]){
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
416 case 0:
1053
f07fd48c23d4 direct blocksize in bframes fix (might fix qpel+bframe bug)
michaelni
parents: 1042
diff changeset
417 s->mv[0][0][0] = s->mv[0][1][0] = s->mv[0][2][0] = s->mv[0][3][0] = s->motion_val[xy][0]*time_pb/time_pp + mx;
f07fd48c23d4 direct blocksize in bframes fix (might fix qpel+bframe bug)
michaelni
parents: 1042
diff changeset
418 s->mv[0][0][1] = s->mv[0][1][1] = s->mv[0][2][1] = s->mv[0][3][1] = s->motion_val[xy][1]*time_pb/time_pp + my;
f07fd48c23d4 direct blocksize in bframes fix (might fix qpel+bframe bug)
michaelni
parents: 1042
diff changeset
419 s->mv[1][0][0] = s->mv[1][1][0] = s->mv[1][2][0] = s->mv[1][3][0] = mx ? s->mv[0][0][0] - s->motion_val[xy][0]
936
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
420 : s->motion_val[xy][0]*(time_pb - time_pp)/time_pp;
1053
f07fd48c23d4 direct blocksize in bframes fix (might fix qpel+bframe bug)
michaelni
parents: 1042
diff changeset
421 s->mv[1][0][1] = s->mv[1][1][1] = s->mv[1][2][1] = s->mv[1][3][1] = my ? s->mv[0][0][1] - s->motion_val[xy][1]
936
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
422 : s->motion_val[xy][1]*(time_pb - time_pp)/time_pp;
1053
f07fd48c23d4 direct blocksize in bframes fix (might fix qpel+bframe bug)
michaelni
parents: 1042
diff changeset
423 if((s->avctx->workaround_bugs & FF_BUG_DIRECT_BLOCKSIZE) || !s->quarter_sample)
f07fd48c23d4 direct blocksize in bframes fix (might fix qpel+bframe bug)
michaelni
parents: 1042
diff changeset
424 s->mv_type= MV_TYPE_16X16;
f07fd48c23d4 direct blocksize in bframes fix (might fix qpel+bframe bug)
michaelni
parents: 1042
diff changeset
425 else
f07fd48c23d4 direct blocksize in bframes fix (might fix qpel+bframe bug)
michaelni
parents: 1042
diff changeset
426 s->mv_type= MV_TYPE_8X8;
936
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
427 break;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
428 case CO_LOCATED_TYPE_4MV:
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
429 s->mv_type = MV_TYPE_8X8;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
430 for(i=0; i<4; i++){
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
431 xy= s->block_index[i];
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
432 s->mv[0][i][0] = s->motion_val[xy][0]*time_pb/time_pp + mx;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
433 s->mv[0][i][1] = s->motion_val[xy][1]*time_pb/time_pp + my;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
434 s->mv[1][i][0] = mx ? s->mv[0][i][0] - s->motion_val[xy][0]
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
435 : s->motion_val[xy][0]*(time_pb - time_pp)/time_pp;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
436 s->mv[1][i][1] = my ? s->mv[0][i][1] - s->motion_val[xy][1]
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
437 : s->motion_val[xy][1]*(time_pb - time_pp)/time_pp;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
438 }
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
439 break;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
440 case CO_LOCATED_TYPE_FIELDMV:
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
441 s->mv_type = MV_TYPE_FIELD;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
442 for(i=0; i<2; i++){
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
443 if(s->top_field_first){
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
444 time_pp= s->pp_field_time - s->field_select_table[mb_index][i] + i;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
445 time_pb= s->pb_field_time - s->field_select_table[mb_index][i] + i;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
446 }else{
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
447 time_pp= s->pp_field_time + s->field_select_table[mb_index][i] - i;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
448 time_pb= s->pb_field_time + s->field_select_table[mb_index][i] - i;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
449 }
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
450 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
451 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
452 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
453 : s->field_mv_table[mb_index][i][0]*(time_pb - time_pp)/time_pp;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
454 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
455 : s->field_mv_table[mb_index][i][1]*(time_pb - time_pp)/time_pp;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
456 }
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
457 break;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
458 }
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
459 }
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
460
815
78accc54493b put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents: 770
diff changeset
461 #ifdef CONFIG_ENCODERS
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
462 void mpeg4_encode_mb(MpegEncContext * s,
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
463 DCTELEM block[6][64],
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
464 int motion_x, int motion_y)
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
465 {
1057
bb5de8a59da8 * static,const,compiler warning cleanup
kabi
parents: 1053
diff changeset
466 int cbpc, cbpy, pred_x, pred_y;
286
91f7c38f5f37 statistics for 2-pass encoding
michaelni
parents: 285
diff changeset
467 int bits;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
468 PutBitContext * const pb2 = s->data_partitioning ? &s->pb2 : &s->pb;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
469 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
470 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
471 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
472 const int dquant_code[5]= {1,0,9,2,3};
162
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
473
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
474 // 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
475 if (!s->mb_intra) {
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
476 /* compute cbp */
1057
bb5de8a59da8 * static,const,compiler warning cleanup
kabi
parents: 1053
diff changeset
477 int i, cbp = 0;
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
478 for (i = 0; i < 6; i++) {
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
479 if (s->block_last_index[i] >= 0)
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
480 cbp |= 1 << (5 - i);
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
481 }
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
482
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
483 if(s->pict_type==B_TYPE){
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
484 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
485 int mb_type= mb_type_table[s->mv_dir];
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
486
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
487 if(s->mb_x==0){
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
488 s->last_mv[0][0][0]=
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
489 s->last_mv[0][0][1]=
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
490 s->last_mv[1][0][0]=
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
491 s->last_mv[1][0][1]= 0;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
492 }
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
493
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
494 assert(s->dquant>=-2 && s->dquant<=2);
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
495 assert((s->dquant&1)==0);
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
496 assert(mb_type>=0);
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
497
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
498 /* nothing to do if this MB was skiped in the next P Frame */
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
499 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
500 s->skip_count++;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
501 s->mv[0][0][0]=
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
502 s->mv[0][0][1]=
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
503 s->mv[1][0][0]=
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
504 s->mv[1][0][1]= 0;
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
505 s->mv_dir= MV_DIR_FORWARD; //doesnt matter
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
506 s->qscale -= s->dquant;
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
507 // s->mb_skiped=1;
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
508
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
509 return;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
510 }
936
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
511
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
512 if ((cbp | motion_x | motion_y | mb_type) ==0) {
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
513 /* direct MB with MV={0,0} */
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
514 assert(s->dquant==0);
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
515
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
516 put_bits(&s->pb, 1, 1); /* mb not coded modb1=1 */
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
517
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
518 if(interleaved_stats){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
519 s->misc_bits++;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
520 s->last_bits++;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
521 }
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
522 s->skip_count++;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
523 return;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
524 }
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
525
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
526 put_bits(&s->pb, 1, 0); /* mb coded modb1=0 */
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
527 put_bits(&s->pb, 1, cbp ? 0 : 1); /* modb2 */ //FIXME merge
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
528 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
529 if(cbp) put_bits(&s->pb, 6, cbp);
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
530
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
531 if(cbp && mb_type){
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
532 if(s->dquant)
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
533 put_bits(&s->pb, 2, (s->dquant>>2)+3);
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
534 else
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
535 put_bits(&s->pb, 1, 0);
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
536 }else
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
537 s->qscale -= s->dquant;
697
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
538
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
539 if(!s->progressive_sequence){
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
540 if(cbp)
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
541 put_bits(&s->pb, 1, s->interlaced_dct);
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
542 if(mb_type) // not diect mode
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
543 put_bits(&s->pb, 1, 0); // no interlaced ME yet
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
544 }
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
545
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
546 if(interleaved_stats){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
547 bits= get_bit_count(&s->pb);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
548 s->misc_bits+= bits - s->last_bits;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
549 s->last_bits=bits;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
550 }
295
6622b0fd036c mpeg4 4MV encoding
michaelni
parents: 294
diff changeset
551
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
552 switch(mb_type)
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
553 {
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
554 case 0: /* direct */
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
555 h263_encode_motion(s, motion_x, 1);
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
556 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
557 s->b_count++;
e47fa3e3f2d5 statistics for forw & back p-MBs instead of just one counter for both
michaelni
parents: 654
diff changeset
558 s->f_count++;
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
559 break;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
560 case 1: /* bidir */
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
561 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
562 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
563 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
564 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
565 s->last_mv[0][0][0]= s->mv[0][0][0];
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
566 s->last_mv[0][0][1]= s->mv[0][0][1];
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
567 s->last_mv[1][0][0]= s->mv[1][0][0];
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
568 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
569 s->b_count++;
e47fa3e3f2d5 statistics for forw & back p-MBs instead of just one counter for both
michaelni
parents: 654
diff changeset
570 s->f_count++;
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
571 break;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
572 case 2: /* backward */
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
573 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
574 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
575 s->last_mv[1][0][0]= motion_x;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
576 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
577 s->b_count++;
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
578 break;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
579 case 3: /* forward */
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
580 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
581 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
582 s->last_mv[0][0][0]= motion_x;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
583 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
584 s->f_count++;
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
585 break;
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
586 default:
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
587 printf("unknown mb type\n");
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
588 return;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
589 }
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
590
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
591 if(interleaved_stats){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
592 bits= get_bit_count(&s->pb);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
593 s->mv_bits+= bits - s->last_bits;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
594 s->last_bits=bits;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
595 }
295
6622b0fd036c mpeg4 4MV encoding
michaelni
parents: 294
diff changeset
596
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
597 /* encode each block */
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
598 for (i = 0; i < 6; i++) {
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
599 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
600 }
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
601
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
602 if(interleaved_stats){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
603 bits= get_bit_count(&s->pb);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
604 s->p_tex_bits+= bits - s->last_bits;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
605 s->last_bits=bits;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
606 }
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
607 }else{ /* s->pict_type==B_TYPE */
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
608 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
609 /* 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
610 why didnt they just compress the skip-mb bits instead of reusing them ?! */
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
611 if(s->max_b_frames>0){
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
612 int i;
364
6b6332e7008a segfault fix for b-frame encoding with height%16!=0
michaelni
parents: 360
diff changeset
613 int x,y, offset;
6b6332e7008a segfault fix for b-frame encoding with height%16!=0
michaelni
parents: 360
diff changeset
614 uint8_t *p_pic;
6b6332e7008a segfault fix for b-frame encoding with height%16!=0
michaelni
parents: 360
diff changeset
615
6b6332e7008a segfault fix for b-frame encoding with height%16!=0
michaelni
parents: 360
diff changeset
616 x= s->mb_x*16;
6b6332e7008a segfault fix for b-frame encoding with height%16!=0
michaelni
parents: 360
diff changeset
617 y= s->mb_y*16;
6b6332e7008a segfault fix for b-frame encoding with height%16!=0
michaelni
parents: 360
diff changeset
618 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
619 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
620
6b6332e7008a segfault fix for b-frame encoding with height%16!=0
michaelni
parents: 360
diff changeset
621 offset= x + y*s->linesize;
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
622 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
623
331
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
624 s->mb_skiped=1;
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
625 for(i=0; i<s->max_b_frames; i++){
339
b743a6bbab25 segfault fix
michaelni
parents: 336
diff changeset
626 uint8_t *b_pic;
b743a6bbab25 segfault fix
michaelni
parents: 336
diff changeset
627 int diff;
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
628 Picture *pic= s->reordered_input_picture[i+1];
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
629
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
630 if(pic==NULL || pic->pict_type!=B_TYPE) break;
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
631
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
632 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
633 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
634 if(diff>s->qscale*70){ //FIXME check that 70 is optimal
331
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
635 s->mb_skiped=0;
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
636 break;
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
637 }
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
638 }
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
639 }else
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
640 s->mb_skiped=1;
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
641
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
642 if(s->mb_skiped==1){
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
643 /* skip macroblock */
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
644 put_bits(&s->pb, 1, 1);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
645
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
646 if(interleaved_stats){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
647 s->misc_bits++;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
648 s->last_bits++;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
649 }
331
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
650 s->skip_count++;
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
651 return;
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
652 }
295
6622b0fd036c mpeg4 4MV encoding
michaelni
parents: 294
diff changeset
653 }
364
6b6332e7008a segfault fix for b-frame encoding with height%16!=0
michaelni
parents: 360
diff changeset
654
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
655 put_bits(&s->pb, 1, 0); /* mb coded */
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
656 if(s->mv_type==MV_TYPE_16X16){
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
657 cbpc = cbp & 3;
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
658 if(s->dquant) cbpc+= 8;
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
659 put_bits(&s->pb,
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
660 inter_MCBPC_bits[cbpc],
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
661 inter_MCBPC_code[cbpc]);
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
662
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
663 cbpy = cbp >> 2;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
664 cbpy ^= 0xf;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
665 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
666 if(s->dquant)
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
667 put_bits(pb2, 2, dquant_code[s->dquant+2]);
697
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
668
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
669 if(!s->progressive_sequence){
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
670 if(cbp)
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
671 put_bits(pb2, 1, s->interlaced_dct);
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
672 put_bits(pb2, 1, 0); // no interlaced ME yet
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
673 }
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
674
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
675 if(interleaved_stats){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
676 bits= get_bit_count(&s->pb);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
677 s->misc_bits+= bits - s->last_bits;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
678 s->last_bits=bits;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
679 }
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
680
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
681 /* motion vectors: 16x16 mode */
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
682 h263_pred_motion(s, 0, &pred_x, &pred_y);
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
683
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
684 h263_encode_motion(s, motion_x - pred_x, s->f_code);
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
685 h263_encode_motion(s, motion_y - pred_y, s->f_code);
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
686 }else{
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
687 cbpc = (cbp & 3)+16;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
688 put_bits(&s->pb,
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
689 inter_MCBPC_bits[cbpc],
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
690 inter_MCBPC_code[cbpc]);
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
691 cbpy = cbp >> 2;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
692 cbpy ^= 0xf;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
693 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
694
757
d031d1575ceb fixing interlaced dct with 4mv
michaelni
parents: 753
diff changeset
695 if(!s->progressive_sequence){
d031d1575ceb fixing interlaced dct with 4mv
michaelni
parents: 753
diff changeset
696 if(cbp)
d031d1575ceb fixing interlaced dct with 4mv
michaelni
parents: 753
diff changeset
697 put_bits(pb2, 1, s->interlaced_dct);
d031d1575ceb fixing interlaced dct with 4mv
michaelni
parents: 753
diff changeset
698 }
d031d1575ceb fixing interlaced dct with 4mv
michaelni
parents: 753
diff changeset
699
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
700 if(interleaved_stats){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
701 bits= get_bit_count(&s->pb);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
702 s->misc_bits+= bits - s->last_bits;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
703 s->last_bits=bits;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
704 }
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
705
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
706 for(i=0; i<4; i++){
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
707 /* motion vectors: 8x8 mode*/
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
708 h263_pred_motion(s, i, &pred_x, &pred_y);
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
709
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
710 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
711 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
712 }
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
713 }
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
714
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
715 if(interleaved_stats){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
716 bits= get_bit_count(&s->pb);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
717 s->mv_bits+= bits - s->last_bits;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
718 s->last_bits=bits;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
719 }
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
720
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
721 /* encode each block */
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
722 for (i = 0; i < 6; i++) {
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
723 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
724 }
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
725
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
726 if(interleaved_stats){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
727 bits= get_bit_count(&s->pb);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
728 s->p_tex_bits+= bits - s->last_bits;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
729 s->last_bits=bits;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
730 }
656
e47fa3e3f2d5 statistics for forw & back p-MBs instead of just one counter for both
michaelni
parents: 654
diff changeset
731 s->f_count++;
295
6622b0fd036c mpeg4 4MV encoding
michaelni
parents: 294
diff changeset
732 }
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
733 } else {
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
734 int cbp;
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
735 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
736 int dir[6]; //prediction direction
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
737 int zigzag_last_index[6];
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
738 uint8_t *scan_table[6];
1057
bb5de8a59da8 * static,const,compiler warning cleanup
kabi
parents: 1053
diff changeset
739 int i;
265
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 for(i=0; i<6; i++){
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
742 const int level= block[i][0];
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
743 uint16_t *dc_ptr;
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
744
498
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
745 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
746 if (i < 4) {
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
747 *dc_ptr = level * s->y_dc_scale;
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
748 } else {
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
749 *dc_ptr = level * s->c_dc_scale;
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
750 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
751 }
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 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
754
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
755 if(s->ac_pred){
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
756 for(i=0; i<6; i++){
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
757 uint8_t *st;
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
758 int last_index;
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
759
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
760 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
761 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
762 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
763
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
764 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
765 if(block[i][st[last_index]]) break;
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
766 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
767 s->block_last_index[i]= last_index;
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
768 scan_table[i]= st;
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 }else{
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
771 for(i=0; i<6; i++)
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
772 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
773 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
774
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
775 /* compute cbp */
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
776 cbp = 0;
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
777 for (i = 0; i < 6; i++) {
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
778 if (s->block_last_index[i] >= 1)
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
779 cbp |= 1 << (5 - i);
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
780 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
781
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
782 cbpc = cbp & 3;
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
783 if (s->pict_type == I_TYPE) {
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
784 if(s->dquant) cbpc+=4;
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
785 put_bits(&s->pb,
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
786 intra_MCBPC_bits[cbpc],
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
787 intra_MCBPC_code[cbpc]);
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
788 } else {
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
789 if(s->dquant) cbpc+=8;
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
790 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
791 put_bits(&s->pb,
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
792 inter_MCBPC_bits[cbpc + 4],
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
793 inter_MCBPC_code[cbpc + 4]);
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
794 }
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
795 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
796 cbpy = cbp >> 2;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
797 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
798 if(s->dquant)
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
799 put_bits(dc_pb, 2, dquant_code[s->dquant+2]);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
800
697
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
801 if(!s->progressive_sequence){
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
802 put_bits(dc_pb, 1, s->interlaced_dct);
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
803 }
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
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->misc_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
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
811 /* encode each block */
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
812 for (i = 0; i < 6; i++) {
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
813 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
814 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
815
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
816 if(interleaved_stats){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
817 bits= get_bit_count(&s->pb);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
818 s->i_tex_bits+= bits - s->last_bits;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
819 s->last_bits=bits;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
820 }
286
91f7c38f5f37 statistics for 2-pass encoding
michaelni
parents: 285
diff changeset
821 s->i_count++;
91f7c38f5f37 statistics for 2-pass encoding
michaelni
parents: 285
diff changeset
822
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
823 /* 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
824 if(s->ac_pred){
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
825 for(i=0; i<6; i++){
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
826 int j;
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
827 int16_t *ac_val;
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
828
266
252444e5259b optimization
michaelni
parents: 265
diff changeset
829 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
830
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
831 if(dir[i]){
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
832 for(j=1; j<8; j++)
1092
f59c3f66363b MpegEncContext.(i)dct_* -> DspContext.(i)dct_*
michaelni
parents: 1090
diff changeset
833 block[i][s->dsp.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
834 }else{
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
835 for(j=1; j<8; j++)
1092
f59c3f66363b MpegEncContext.(i)dct_* -> DspContext.(i)dct_*
michaelni
parents: 1090
diff changeset
836 block[i][s->dsp.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
837 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
838 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
839 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
840 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
841 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
842 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
843
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
844 void h263_encode_mb(MpegEncContext * s,
986e461dc072 Initial revision
glantau
parents:
diff changeset
845 DCTELEM block[6][64],
986e461dc072 Initial revision
glantau
parents:
diff changeset
846 int motion_x, int motion_y)
986e461dc072 Initial revision
glantau
parents:
diff changeset
847 {
986e461dc072 Initial revision
glantau
parents:
diff changeset
848 int cbpc, cbpy, i, cbp, pred_x, pred_y;
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
849 int16_t pred_dc;
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
850 int16_t rec_intradc[6];
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
851 uint16_t *dc_ptr[6];
695
3525da287ee2 adaptive quantization for h263
michaelni
parents: 692
diff changeset
852 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
853
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
854 //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
855 if (!s->mb_intra) {
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
856 /* compute cbp */
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
857 cbp = 0;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
858 for (i = 0; i < 6; i++) {
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
859 if (s->block_last_index[i] >= 0)
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
860 cbp |= 1 << (5 - i);
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
861 }
695
3525da287ee2 adaptive quantization for h263
michaelni
parents: 692
diff changeset
862 if ((cbp | motion_x | motion_y | s->dquant) == 0) {
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
863 /* skip macroblock */
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
864 put_bits(&s->pb, 1, 1);
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
865 return;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
866 }
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
867 put_bits(&s->pb, 1, 0); /* mb coded */
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
868 cbpc = cbp & 3;
695
3525da287ee2 adaptive quantization for h263
michaelni
parents: 692
diff changeset
869 if(s->dquant) cbpc+= 8;
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
870 put_bits(&s->pb,
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
871 inter_MCBPC_bits[cbpc],
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
872 inter_MCBPC_code[cbpc]);
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
873 cbpy = cbp >> 2;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
874 cbpy ^= 0xf;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
875 put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
695
3525da287ee2 adaptive quantization for h263
michaelni
parents: 692
diff changeset
876 if(s->dquant)
3525da287ee2 adaptive quantization for h263
michaelni
parents: 692
diff changeset
877 put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
878
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
879 /* motion vectors: 16x16 mode only now */
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
880 h263_pred_motion(s, 0, &pred_x, &pred_y);
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
881
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
882 if (!s->umvplus) {
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
883 h263_encode_motion(s, motion_x - pred_x, s->f_code);
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
884 h263_encode_motion(s, motion_y - pred_y, s->f_code);
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
885 }
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
886 else {
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
887 h263p_encode_umotion(s, motion_x - pred_x);
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
888 h263p_encode_umotion(s, motion_y - pred_y);
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
889 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
890 /* To prevent Start Code emulation */
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
891 put_bits(&s->pb,1,1);
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
892 }
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
893 } else {
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
894 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
895
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
896 cbp = 0;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
897 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
898 /* Predict DC */
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
899 if (s->h263_aic && s->mb_intra) {
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
900 int16_t level = block[i][0];
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
901
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
902 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
903 level -= pred_dc;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
904 /* Quant */
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
905 if (level < 0)
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
906 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
907 else
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
908 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
909
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
910 /* AIC can change CBP */
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
911 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
912 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
913 else if (level < -127)
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
914 level = -127;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
915 else if (level > 127)
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
916 level = 127;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
917
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
918 block[i][0] = level;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
919 /* Reconstruction */
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
920 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
921 /* Oddify */
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
922 rec_intradc[i] |= 1;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
923 //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
924 // rec_intradc[i]++;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
925 /* Clipping */
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
926 if (rec_intradc[i] < 0)
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
927 rec_intradc[i] = 0;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
928 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
929 rec_intradc[i] = 2047;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
930
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
931 /* Update AC/DC tables */
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
932 *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
933 }
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
934 /* compute cbp */
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
935 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
936 cbp |= 1 << (5 - i);
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
937 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
938
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
939 cbpc = cbp & 3;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
940 if (s->pict_type == I_TYPE) {
695
3525da287ee2 adaptive quantization for h263
michaelni
parents: 692
diff changeset
941 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
942 put_bits(&s->pb,
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
943 intra_MCBPC_bits[cbpc],
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
944 intra_MCBPC_code[cbpc]);
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
945 } else {
695
3525da287ee2 adaptive quantization for h263
michaelni
parents: 692
diff changeset
946 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
947 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
948 put_bits(&s->pb,
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
949 inter_MCBPC_bits[cbpc + 4],
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
950 inter_MCBPC_code[cbpc + 4]);
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
951 }
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
952 if (s->h263_aic) {
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
953 /* 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
954 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
955 }
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
956 cbpy = cbp >> 2;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
957 put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
695
3525da287ee2 adaptive quantization for h263
michaelni
parents: 692
diff changeset
958 if(s->dquant)
3525da287ee2 adaptive quantization for h263
michaelni
parents: 692
diff changeset
959 put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
960 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
961
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
962 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
963 /* encode each block */
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 293
diff changeset
964 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
965
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
966 /* Update INTRADC for decoding */
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
967 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
968 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
969
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
970 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
971 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
972 }
815
78accc54493b put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents: 770
diff changeset
973 #endif
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
974
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
975 static int h263_pred_dc(MpegEncContext * s, int n, uint16_t **dc_val_ptr)
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
976 {
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
977 int x, y, wrap, a, c, pred_dc, scale;
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
978 int16_t *dc_val, *ac_val;
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
979
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
980 /* find prediction */
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
981 if (n < 4) {
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
982 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
983 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
984 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
985 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
986 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
987 scale = s->y_dc_scale;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
988 } else {
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
989 x = s->mb_x + 1;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
990 y = s->mb_y + 1;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
991 wrap = s->mb_width + 2;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
992 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
993 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
994 scale = s->c_dc_scale;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
995 }
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
996 /* B C
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
997 * A X
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
998 */
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
999 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
1000 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
1001
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1002 /* No prediction outside GOB boundary */
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1003 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
1004 c = 1024;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1005 pred_dc = 1024;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1006 /* just DC prediction */
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1007 if (a != 1024 && c != 1024)
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1008 pred_dc = (a + c) >> 1;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1009 else if (a != 1024)
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1010 pred_dc = a;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1011 else
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1012 pred_dc = c;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1013
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1014 /* we assume pred is positive */
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1015 //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
1016 *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
1017 return pred_dc;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1018 }
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1019
1057
bb5de8a59da8 * static,const,compiler warning cleanup
kabi
parents: 1053
diff changeset
1020 static 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
1021 {
249
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1022 int x, y, wrap, a, c, pred_dc, scale, i;
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
1023 int16_t *dc_val, *ac_val, *ac_val1;
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1024
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1025 /* find prediction */
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1026 if (n < 4) {
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1027 x = 2 * s->mb_x + 1 + (n & 1);
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1028 y = 2 * s->mb_y + 1 + ((n & 2) >> 1);
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1029 wrap = s->mb_width * 2 + 2;
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1030 dc_val = s->dc_val[0];
249
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1031 ac_val = s->ac_val[0][0];
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1032 scale = s->y_dc_scale;
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1033 } else {
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1034 x = s->mb_x + 1;
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1035 y = s->mb_y + 1;
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1036 wrap = s->mb_width + 2;
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1037 dc_val = s->dc_val[n - 4 + 1];
249
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1038 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
1039 scale = s->c_dc_scale;
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1040 }
249
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1041
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1042 ac_val += ((y) * wrap + (x)) * 16;
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1043 ac_val1 = ac_val;
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1044
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1045 /* B C
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1046 * A X
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1047 */
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1048 a = dc_val[(x - 1) + (y) * wrap];
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1049 c = dc_val[(x) + (y - 1) * wrap];
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1050
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1051 /* No prediction outside GOB boundary */
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1052 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
1053 c = 1024;
249
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1054 pred_dc = 1024;
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1055 if (s->ac_pred) {
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1056 if (s->h263_aic_dir) {
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1057 /* left prediction */
249
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1058 if (a != 1024) {
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1059 ac_val -= 16;
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1060 for(i=1;i<8;i++) {
1092
f59c3f66363b MpegEncContext.(i)dct_* -> DspContext.(i)dct_*
michaelni
parents: 1090
diff changeset
1061 block[s->dsp.idct_permutation[i<<3]] += ac_val[i];
249
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1062 }
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1063 pred_dc = a;
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1064 }
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1065 } else {
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1066 /* top prediction */
249
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1067 if (c != 1024) {
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1068 ac_val -= 16 * wrap;
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1069 for(i=1;i<8;i++) {
1092
f59c3f66363b MpegEncContext.(i)dct_* -> DspContext.(i)dct_*
michaelni
parents: 1090
diff changeset
1070 block[s->dsp.idct_permutation[i ]] += ac_val[i + 8];
249
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1071 }
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 }
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1074 }
249
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1075 } else {
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1076 /* just DC prediction */
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1077 if (a != 1024 && c != 1024)
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1078 pred_dc = (a + c) >> 1;
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1079 else if (a != 1024)
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1080 pred_dc = a;
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1081 else
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1082 pred_dc = c;
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1083 }
249
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1084
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1085 /* we assume pred is positive */
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1086 block[0]=block[0]*scale + pred_dc;
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1087
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1088 if (block[0] < 0)
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1089 block[0] = 0;
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1090 else if (!(block[0] & 1))
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1091 block[0]++;
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1092
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1093 /* Update AC/DC tables */
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1094 dc_val[(x) + (y) * wrap] = block[0];
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1095
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1096 /* left copy */
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1097 for(i=1;i<8;i++)
1092
f59c3f66363b MpegEncContext.(i)dct_* -> DspContext.(i)dct_*
michaelni
parents: 1090
diff changeset
1098 ac_val1[i ] = block[s->dsp.idct_permutation[i<<3]];
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1099 /* top copy */
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1100 for(i=1;i<8;i++)
1092
f59c3f66363b MpegEncContext.(i)dct_* -> DspContext.(i)dct_*
michaelni
parents: 1090
diff changeset
1101 ac_val1[8 + i] = block[s->dsp.idct_permutation[i ]];
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1102 }
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1103
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
1104 int16_t *h263_pred_motion(MpegEncContext * s, int block,
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1105 int *px, int *py)
986e461dc072 Initial revision
glantau
parents:
diff changeset
1106 {
266
252444e5259b optimization
michaelni
parents: 265
diff changeset
1107 int xy, wrap;
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
1108 int16_t *A, *B, *C, *mot_val;
264
28c5c62b1c4c support decoding (with mplayer) of 3 .mp4 files from mphq
michaelni
parents: 263
diff changeset
1109 static const int off[4]= {2, 1, 1, -1};
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1110
266
252444e5259b optimization
michaelni
parents: 265
diff changeset
1111 wrap = s->block_wrap[0];
252444e5259b optimization
michaelni
parents: 265
diff changeset
1112 xy = s->block_index[block];
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1113
245
a023f78e0cc2 * simplified indexing
kabi
parents: 241
diff changeset
1114 mot_val = s->motion_val[xy];
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1115
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1116 A = s->motion_val[xy - 1];
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1117 /* special case for first (slice) line */
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
1118 if (s->first_slice_line && block<3) {
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1119 // 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
1120 // 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
1121 if(block==0){ //most common case
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1122 if(s->mb_x == s->resync_mb_x){ //rare
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1123 *px= *py = 0;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1124 }else if(s->mb_x + 1 == s->resync_mb_x){ //rare
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1125 C = s->motion_val[xy + off[block] - wrap];
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1126 if(s->mb_x==0){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1127 *px = C[0];
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1128 *py = C[1];
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1129 }else{
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 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1133 }else{
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1134 *px = A[0];
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1135 *py = A[1];
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1136 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1137 }else if(block==1){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1138 if(s->mb_x + 1 == s->resync_mb_x){ //rare
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1139 C = s->motion_val[xy + off[block] - wrap];
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1140 *px = mid_pred(A[0], 0, C[0]);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1141 *py = mid_pred(A[1], 0, C[1]);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1142 }else{
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1143 *px = A[0];
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1144 *py = A[1];
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1145 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1146 }else{ /* block==2*/
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1147 B = s->motion_val[xy - wrap];
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1148 C = s->motion_val[xy + off[block] - wrap];
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1149 if(s->mb_x == s->resync_mb_x) //rare
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1150 A[0]=A[1]=0;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1151
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1152 *px = mid_pred(A[0], B[0], C[0]);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1153 *py = mid_pred(A[1], B[1], C[1]);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1154 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1155 } else {
264
28c5c62b1c4c support decoding (with mplayer) of 3 .mp4 files from mphq
michaelni
parents: 263
diff changeset
1156 B = s->motion_val[xy - wrap];
28c5c62b1c4c support decoding (with mplayer) of 3 .mp4 files from mphq
michaelni
parents: 263
diff changeset
1157 C = s->motion_val[xy + off[block] - wrap];
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1158 *px = mid_pred(A[0], B[0], C[0]);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1159 *py = mid_pred(A[1], B[1], C[1]);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1160 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1161 return mot_val;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1162 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1163
815
78accc54493b put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents: 770
diff changeset
1164 #ifdef CONFIG_ENCODERS
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
1165 static void h263_encode_motion(MpegEncContext * s, int val, int f_code)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1166 {
702
2cff6fc37716 minor optimization of h263_encode_motion()
michaelni
parents: 701
diff changeset
1167 int range, l, bit_size, sign, code, bits;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1168
986e461dc072 Initial revision
glantau
parents:
diff changeset
1169 if (val == 0) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1170 /* zero vector */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1171 code = 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1172 put_bits(&s->pb, mvtab[code][1], mvtab[code][0]);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1173 } else {
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
1174 bit_size = f_code - 1;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1175 range = 1 << bit_size;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1176 /* modulo encoding */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1177 l = range * 32;
702
2cff6fc37716 minor optimization of h263_encode_motion()
michaelni
parents: 701
diff changeset
1178 #if 1
2cff6fc37716 minor optimization of h263_encode_motion()
michaelni
parents: 701
diff changeset
1179 val+= l;
2cff6fc37716 minor optimization of h263_encode_motion()
michaelni
parents: 701
diff changeset
1180 val&= 2*l-1;
2cff6fc37716 minor optimization of h263_encode_motion()
michaelni
parents: 701
diff changeset
1181 val-= l;
2cff6fc37716 minor optimization of h263_encode_motion()
michaelni
parents: 701
diff changeset
1182 sign = val>>31;
2cff6fc37716 minor optimization of h263_encode_motion()
michaelni
parents: 701
diff changeset
1183 val= (val^sign)-sign;
2cff6fc37716 minor optimization of h263_encode_motion()
michaelni
parents: 701
diff changeset
1184 sign&=1;
2cff6fc37716 minor optimization of h263_encode_motion()
michaelni
parents: 701
diff changeset
1185 #else
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1186 if (val < -l) {
702
2cff6fc37716 minor optimization of h263_encode_motion()
michaelni
parents: 701
diff changeset
1187 val += 2*l;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1188 } else if (val >= l) {
702
2cff6fc37716 minor optimization of h263_encode_motion()
michaelni
parents: 701
diff changeset
1189 val -= 2*l;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1190 }
702
2cff6fc37716 minor optimization of h263_encode_motion()
michaelni
parents: 701
diff changeset
1191
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
1192 assert(val>=-l && val<l);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1193
986e461dc072 Initial revision
glantau
parents:
diff changeset
1194 if (val >= 0) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1195 sign = 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1196 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1197 val = -val;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1198 sign = 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1199 }
702
2cff6fc37716 minor optimization of h263_encode_motion()
michaelni
parents: 701
diff changeset
1200 #endif
312
8cf5507e6ca5 mpeg4 mpeg quantizer support
michaelni
parents: 301
diff changeset
1201 val--;
8cf5507e6ca5 mpeg4 mpeg quantizer support
michaelni
parents: 301
diff changeset
1202 code = (val >> bit_size) + 1;
8cf5507e6ca5 mpeg4 mpeg quantizer support
michaelni
parents: 301
diff changeset
1203 bits = val & (range - 1);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1204
986e461dc072 Initial revision
glantau
parents:
diff changeset
1205 put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1206 if (bit_size > 0) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1207 put_bits(&s->pb, bit_size, bits);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1208 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1209 }
718
16dab8296293 fixing custom quantizer matrix decoding
michaelni
parents: 706
diff changeset
1210
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1211 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1212
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1213 /* Encode MV differences on H.263+ with Unrestricted MV mode */
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1214 static void h263p_encode_umotion(MpegEncContext * s, int val)
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1215 {
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1216 short sval = 0;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1217 short i = 0;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1218 short n_bits = 0;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1219 short temp_val;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1220 int code = 0;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1221 int tcode;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1222
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1223 if ( val == 0)
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1224 put_bits(&s->pb, 1, 1);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1225 else if (val == 1)
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1226 put_bits(&s->pb, 3, 0);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1227 else if (val == -1)
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1228 put_bits(&s->pb, 3, 2);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1229 else {
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1230
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1231 sval = ((val < 0) ? (short)(-val):(short)val);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1232 temp_val = sval;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1233
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1234 while (temp_val != 0) {
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1235 temp_val = temp_val >> 1;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1236 n_bits++;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1237 }
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1238
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1239 i = n_bits - 1;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1240 while (i > 0) {
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1241 tcode = (sval & (1 << (i-1))) >> (i-1);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1242 tcode = (tcode << 1) | 1;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1243 code = (code << 2) | tcode;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1244 i--;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1245 }
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1246 code = ((code << 1) | (val < 0)) << 1;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1247 put_bits(&s->pb, (2*n_bits)+1, code);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1248 //printf("\nVal = %d\tCode = %d", sval, code);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1249 }
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1250 }
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1251
277
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1252 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
1253 {
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1254 int f_code;
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1255 int mv;
815
78accc54493b put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents: 770
diff changeset
1256
78accc54493b put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents: 770
diff changeset
1257 if(mv_penalty==NULL)
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
1258 mv_penalty= av_mallocz( sizeof(uint16_t)*(MAX_FCODE+1)*(2*MAX_MV+1) );
815
78accc54493b put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents: 770
diff changeset
1259
277
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1260 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
1261 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
1262 int len;
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1263
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1264 if(mv==0) len= mvtab[0][1];
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1265 else{
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1266 int val, bit_size, range, code;
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1267
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1268 bit_size = s->f_code - 1;
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1269 range = 1 << 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 val=mv;
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1272 if (val < 0)
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1273 val = -val;
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1274 val--;
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1275 code = (val >> bit_size) + 1;
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1276 if(code<33){
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1277 len= mvtab[code][1] + 1 + bit_size;
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1278 }else{
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1279 len= mvtab[32][1] + 2 + bit_size;
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 }
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1282
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1283 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
1284 }
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1285 }
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1286
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1287 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
1288 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
1289 fcode_tab[mv+MAX_MV]= f_code;
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1290 }
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1291 }
287
32a3dcce2e9b fixing motion estimation with h263p hopefully
michaelni
parents: 286
diff changeset
1292
32a3dcce2e9b fixing motion estimation with h263p hopefully
michaelni
parents: 286
diff changeset
1293 for(mv=0; mv<MAX_MV*2+1; mv++){
32a3dcce2e9b fixing motion estimation with h263p hopefully
michaelni
parents: 286
diff changeset
1294 umv_fcode_tab[mv]= 1;
32a3dcce2e9b fixing motion estimation with h263p hopefully
michaelni
parents: 286
diff changeset
1295 }
277
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1296 }
815
78accc54493b put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents: 770
diff changeset
1297 #endif
277
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1298
1070
6da5ae9ee199 more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents: 1068
diff changeset
1299 #ifdef CONFIG_ENCODERS
6da5ae9ee199 more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents: 1068
diff changeset
1300
468
1e23eae32087 Minor warning cleanup.
mellum
parents: 453
diff changeset
1301 static void init_uni_dc_tab(void)
293
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1302 {
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1303 int level, uni_code, uni_len;
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1304
312
8cf5507e6ca5 mpeg4 mpeg quantizer support
michaelni
parents: 301
diff changeset
1305 for(level=-256; level<256; level++){
293
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1306 int size, v, l;
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1307 /* find number of bits */
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1308 size = 0;
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1309 v = abs(level);
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1310 while (v) {
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1311 v >>= 1;
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1312 size++;
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1313 }
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1314
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1315 if (level < 0)
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1316 l= (-level) ^ ((1 << size) - 1);
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1317 else
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1318 l= level;
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1319
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1320 /* luminance */
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1321 uni_code= DCtab_lum[size][0];
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1322 uni_len = DCtab_lum[size][1];
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1323
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1324 if (size > 0) {
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1325 uni_code<<=size; uni_code|=l;
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1326 uni_len+=size;
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1327 if (size > 8){
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1328 uni_code<<=1; uni_code|=1;
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1329 uni_len++;
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1330 }
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1331 }
1013
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1008
diff changeset
1332 uni_DCtab_lum_bits[level+256]= uni_code;
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1008
diff changeset
1333 uni_DCtab_lum_len [level+256]= uni_len;
293
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1334
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1335 /* chrominance */
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1336 uni_code= DCtab_chrom[size][0];
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1337 uni_len = DCtab_chrom[size][1];
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1338
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1339 if (size > 0) {
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1340 uni_code<<=size; uni_code|=l;
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1341 uni_len+=size;
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1342 if (size > 8){
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1343 uni_code<<=1; uni_code|=1;
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1344 uni_len++;
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1345 }
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1346 }
1013
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1008
diff changeset
1347 uni_DCtab_chrom_bits[level+256]= uni_code;
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1008
diff changeset
1348 uni_DCtab_chrom_len [level+256]= uni_len;
293
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1349
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1350 }
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1351 }
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1352
1070
6da5ae9ee199 more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents: 1068
diff changeset
1353 #endif //CONFIG_ENCODERS
6da5ae9ee199 more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents: 1068
diff changeset
1354
815
78accc54493b put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents: 770
diff changeset
1355 #ifdef CONFIG_ENCODERS
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
1356 static void init_uni_mpeg4_rl_tab(RLTable *rl, uint32_t *bits_tab, uint8_t *len_tab){
648
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1357 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
1358
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream 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 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
1360 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
1361
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1362 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
1363 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
1364 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
1365 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
1366 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
1367 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
1368 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
1369 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
1370 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
1371
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream 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 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
1373
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream 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 /* 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
1375 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
1376 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
1377 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
1378 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
1379
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream 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 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
1381 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
1382 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
1383 }
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1384 #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
1385 /* 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
1386 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
1387 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
1388 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
1389 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
1390 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
1391 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
1392 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
1393 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
1394 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
1395 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
1396
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream 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 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
1398 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
1399 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
1400 }
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream 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 #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
1403 #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
1404 /* 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
1405 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
1406 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
1407 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
1408 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
1409 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
1410 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
1411 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
1412 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
1413 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
1414 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
1415
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream 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 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
1417 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
1418 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
1419 }
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream 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 }
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream 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 #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
1422 /* 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
1423 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
1424 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
1425 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
1426 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
1427 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
1428 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
1429 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
1430 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
1431
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1432 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
1433 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
1434 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
1435 }
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1436 }
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1437 }
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1438 }
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream 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
277
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1441 void h263_encode_init(MpegEncContext *s)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1442 {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1443 static int done = 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1444
986e461dc072 Initial revision
glantau
parents:
diff changeset
1445 if (!done) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1446 done = 1;
293
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1447
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1448 init_uni_dc_tab();
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1449
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1450 init_rl(&rl_inter);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1451 init_rl(&rl_intra);
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1452 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
1453
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1454 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
1455 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
1456
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1457 init_mv_penalty_and_fcode(s);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1458 }
936
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
1459 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
1460
287
32a3dcce2e9b fixing motion estimation with h263p hopefully
michaelni
parents: 286
diff changeset
1461 // use fcodes >1 only for mpeg4 & h263 & h263p FIXME
344
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
1462 switch(s->codec_id){
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
1463 case CODEC_ID_MPEG4:
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
1464 s->fcode_tab= fcode_tab;
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
1465 s->min_qcoeff= -2048;
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
1466 s->max_qcoeff= 2047;
945
463f7260b155 trellis quantization
michaelni
parents: 942
diff changeset
1467 s->intra_ac_vlc_length = uni_mpeg4_intra_rl_len;
463f7260b155 trellis quantization
michaelni
parents: 942
diff changeset
1468 s->intra_ac_vlc_last_length= uni_mpeg4_intra_rl_len + 128*64;
463f7260b155 trellis quantization
michaelni
parents: 942
diff changeset
1469 s->inter_ac_vlc_length = uni_mpeg4_inter_rl_len;
463f7260b155 trellis quantization
michaelni
parents: 942
diff changeset
1470 s->inter_ac_vlc_last_length= uni_mpeg4_inter_rl_len + 128*64;
1013
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1008
diff changeset
1471 s->luma_dc_vlc_length= uni_DCtab_lum_len;
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1008
diff changeset
1472 s->chroma_dc_vlc_length= uni_DCtab_chrom_len;
945
463f7260b155 trellis quantization
michaelni
parents: 942
diff changeset
1473 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
1474 break;
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
1475 case CODEC_ID_H263P:
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
1476 s->fcode_tab= umv_fcode_tab;
1089
7e79a58954b1 h263(+) clenaup & bugfixes
michaelni
parents: 1070
diff changeset
1477 s->min_qcoeff= -127;
344
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
1478 s->max_qcoeff= 127;
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
1479 break;
498
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
1480 //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
1481 default: //nothing needed default table allready set in mpegvideo.c
1089
7e79a58954b1 h263(+) clenaup & bugfixes
michaelni
parents: 1070
diff changeset
1482 s->min_qcoeff= -127;
344
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
1483 s->max_qcoeff= 127;
498
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
1484 s->y_dc_scale_table=
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
1485 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
344
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
1486 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1487 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1488
1034
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
1489 /**
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
1490 * encodes a 8x8 block.
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
1491 * @param block the 8x8 block
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
1492 * @param n block index (0-3 are luma, 4-5 are chroma)
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
1493 */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1494 static void h263_encode_block(MpegEncContext * s, DCTELEM * block, int n)
986e461dc072 Initial revision
glantau
parents:
diff changeset
1495 {
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1496 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
1497 RLTable *rl;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1498
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1499 rl = &rl_inter;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1500 if (s->mb_intra && !s->h263_aic) {
231
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
1501 /* DC coef */
1089
7e79a58954b1 h263(+) clenaup & bugfixes
michaelni
parents: 1070
diff changeset
1502 level = block[0];
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1503 /* 255 cannot be represented, so we clamp */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1504 if (level > 254) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1505 level = 254;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1506 block[0] = 254;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1507 }
231
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
1508 /* 0 cannot be represented also */
1089
7e79a58954b1 h263(+) clenaup & bugfixes
michaelni
parents: 1070
diff changeset
1509 else if (level < 1) {
231
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
1510 level = 1;
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
1511 block[0] = 1;
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
1512 }
1090
michaelni
parents: 1089
diff changeset
1513 if (level == 128) //FIXME check rv10
1089
7e79a58954b1 h263(+) clenaup & bugfixes
michaelni
parents: 1070
diff changeset
1514 put_bits(&s->pb, 8, 0xff);
7e79a58954b1 h263(+) clenaup & bugfixes
michaelni
parents: 1070
diff changeset
1515 else
7e79a58954b1 h263(+) clenaup & bugfixes
michaelni
parents: 1070
diff changeset
1516 put_bits(&s->pb, 8, level & 0xff);
7e79a58954b1 h263(+) clenaup & bugfixes
michaelni
parents: 1070
diff changeset
1517 i = 1;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1518 } else {
1089
7e79a58954b1 h263(+) clenaup & bugfixes
michaelni
parents: 1070
diff changeset
1519 i = 0;
7e79a58954b1 h263(+) clenaup & bugfixes
michaelni
parents: 1070
diff changeset
1520 if (s->h263_aic && s->mb_intra)
7e79a58954b1 h263(+) clenaup & bugfixes
michaelni
parents: 1070
diff changeset
1521 rl = &rl_intra_aic;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1522 }
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1523
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1524 /* AC coefs */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1525 last_index = s->block_last_index[n];
986e461dc072 Initial revision
glantau
parents:
diff changeset
1526 last_non_zero = i - 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1527 for (; i <= last_index; i++) {
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
1528 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
1529 level = block[j];
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1530 if (level) {
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1531 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
1532 last = (i == last_index);
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1533 sign = 0;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1534 slevel = level;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1535 if (level < 0) {
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1536 sign = 1;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1537 level = -level;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1538 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1539 code = get_rl_index(rl, last, run, level);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1540 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1541 if (code == rl->n) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1542 put_bits(&s->pb, 1, last);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1543 put_bits(&s->pb, 6, run);
1089
7e79a58954b1 h263(+) clenaup & bugfixes
michaelni
parents: 1070
diff changeset
1544
7e79a58954b1 h263(+) clenaup & bugfixes
michaelni
parents: 1070
diff changeset
1545 assert(slevel != 0);
7e79a58954b1 h263(+) clenaup & bugfixes
michaelni
parents: 1070
diff changeset
1546
7e79a58954b1 h263(+) clenaup & bugfixes
michaelni
parents: 1070
diff changeset
1547 if(slevel < 128 && slevel > -128)
7e79a58954b1 h263(+) clenaup & bugfixes
michaelni
parents: 1070
diff changeset
1548 put_bits(&s->pb, 8, slevel & 0xff);
7e79a58954b1 h263(+) clenaup & bugfixes
michaelni
parents: 1070
diff changeset
1549 else{
7e79a58954b1 h263(+) clenaup & bugfixes
michaelni
parents: 1070
diff changeset
1550 put_bits(&s->pb, 8, 128);
7e79a58954b1 h263(+) clenaup & bugfixes
michaelni
parents: 1070
diff changeset
1551 put_bits(&s->pb, 5, slevel & 0x1f);
7e79a58954b1 h263(+) clenaup & bugfixes
michaelni
parents: 1070
diff changeset
1552 put_bits(&s->pb, 6, (slevel>>5)&0x3f);
7e79a58954b1 h263(+) clenaup & bugfixes
michaelni
parents: 1070
diff changeset
1553 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1554 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1555 put_bits(&s->pb, 1, sign);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1556 }
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1557 last_non_zero = i;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1558 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1559 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1560 }
815
78accc54493b put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents: 770
diff changeset
1561 #endif
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1562
1070
6da5ae9ee199 more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents: 1068
diff changeset
1563 #ifdef CONFIG_ENCODERS
6da5ae9ee199 more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents: 1068
diff changeset
1564
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1565 /***************************************************/
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
1566 /**
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
1567 * add mpeg4 stuffing bits (01...1)
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
1568 */
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1569 void ff_mpeg4_stuffing(PutBitContext * pbc)
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1570 {
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1571 int length;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1572 put_bits(pbc, 1, 0);
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1573 length= (-get_bit_count(pbc))&7;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1574 if(length) put_bits(pbc, length, (1<<length)-1);
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1575 }
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
1576
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
1577 /* must be called before writing the header */
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
1578 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
1579 int time_div, time_mod;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
1580
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
1581 if(s->pict_type==I_TYPE){ //we will encode a vol header
1126
77ccf7fe3bd0 per context frame_rate_base, this should finally fix frame_rate related av sync issues
michaelni
parents: 1118
diff changeset
1582 int dummy;
77ccf7fe3bd0 per context frame_rate_base, this should finally fix frame_rate related av sync issues
michaelni
parents: 1118
diff changeset
1583 av_reduce(&s->time_increment_resolution, &dummy, s->avctx->frame_rate, s->avctx->frame_rate_base, (1<<16)-1);
77ccf7fe3bd0 per context frame_rate_base, this should finally fix frame_rate related av sync issues
michaelni
parents: 1118
diff changeset
1584
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
1585 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
1586 }
654
850098147a3c export pts from stream if available
michaelni
parents: 648
diff changeset
1587
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
1588 if(s->current_picture.pts)
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
1589 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
1590 else
1126
77ccf7fe3bd0 per context frame_rate_base, this should finally fix frame_rate related av sync issues
michaelni
parents: 1118
diff changeset
1591 s->time= av_rescale(picture_number*(int64_t)s->avctx->frame_rate_base, s->time_increment_resolution, s->avctx->frame_rate);
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
1592 time_div= s->time/s->time_increment_resolution;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
1593 time_mod= s->time%s->time_increment_resolution;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
1594
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
1595 if(s->pict_type==B_TYPE){
664
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
1596 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
1597 }else{
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
1598 s->last_time_base= s->time_base;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
1599 s->time_base= time_div;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
1600 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
1601 s->last_non_b_time= s->time;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
1602 }
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
1603 }
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
1604
942
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1605 static void mpeg4_encode_gop_header(MpegEncContext * s){
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1606 int hours, minutes, seconds;
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1607
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1608 put_bits(&s->pb, 16, 0);
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1609 put_bits(&s->pb, 16, GOP_STARTCODE);
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1610
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1611 seconds= s->time/s->time_increment_resolution;
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1612 minutes= seconds/60; seconds %= 60;
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1613 hours= minutes/60; minutes %= 60;
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1614 hours%=24;
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1615
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1616 put_bits(&s->pb, 5, hours);
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1617 put_bits(&s->pb, 6, minutes);
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1618 put_bits(&s->pb, 1, 1);
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1619 put_bits(&s->pb, 6, seconds);
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1620
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1621 put_bits(&s->pb, 1, 0); //closed gov == NO
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1622 put_bits(&s->pb, 1, 0); //broken link == NO
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1623
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1624 ff_mpeg4_stuffing(&s->pb);
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1625 }
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1626
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1627 static void mpeg4_encode_visual_object_header(MpegEncContext * s){
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1628 int profile_and_level_indication;
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1629 int vo_ver_id;
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1630
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1631 if(s->max_b_frames || s->quarter_sample){
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1632 profile_and_level_indication= 0xF1; // adv simple level 1
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1633 vo_ver_id= 5;
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1634 }else{
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1635 profile_and_level_indication= 0x01; // simple level 1
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1636 vo_ver_id= 1;
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1637 }
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1638 //FIXME levels
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1639
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1640 put_bits(&s->pb, 16, 0);
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1641 put_bits(&s->pb, 16, VOS_STARTCODE);
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1642
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1643 put_bits(&s->pb, 8, profile_and_level_indication);
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1644
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1645 put_bits(&s->pb, 16, 0);
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1646 put_bits(&s->pb, 16, VISUAL_OBJ_STARTCODE);
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1647
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1648 put_bits(&s->pb, 1, 1);
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1649 put_bits(&s->pb, 4, vo_ver_id);
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1650 put_bits(&s->pb, 3, 1); //priority
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1651
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1652 put_bits(&s->pb, 4, 1); //visual obj type== video obj
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1653
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1654 put_bits(&s->pb, 1, 0); //video signal type == no clue //FIXME
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1655
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1656 ff_mpeg4_stuffing(&s->pb);
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1657 }
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1658
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1659 static void mpeg4_encode_vol_header(MpegEncContext * s, int vo_number, int vol_number)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1660 {
942
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1661 int vo_ver_id;
336
c56b45669214 export delay info
michaelni
parents: 335
diff changeset
1662
942
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1663 if(s->max_b_frames || s->quarter_sample){
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1664 vo_ver_id= 5;
923
3b5d9ecedc73 correct mpeg4 vo type
michaelni
parents: 921
diff changeset
1665 s->vo_type= ADV_SIMPLE_VO_TYPE;
3b5d9ecedc73 correct mpeg4 vo type
michaelni
parents: 921
diff changeset
1666 }else{
942
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1667 vo_ver_id= 1;
923
3b5d9ecedc73 correct mpeg4 vo type
michaelni
parents: 921
diff changeset
1668 s->vo_type= SIMPLE_VO_TYPE;
3b5d9ecedc73 correct mpeg4 vo type
michaelni
parents: 921
diff changeset
1669 }
336
c56b45669214 export delay info
michaelni
parents: 335
diff changeset
1670
263
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1671 put_bits(&s->pb, 16, 0);
942
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1672 put_bits(&s->pb, 16, 0x100 + vo_number); /* video obj */
263
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1673 put_bits(&s->pb, 16, 0);
942
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1674 put_bits(&s->pb, 16, 0x120 + vol_number); /* video obj layer */
263
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1675
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1676 put_bits(&s->pb, 1, 0); /* random access vol */
336
c56b45669214 export delay info
michaelni
parents: 335
diff changeset
1677 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
1678 put_bits(&s->pb, 1, 1); /* is obj layer id= yes */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1679 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
1680 put_bits(&s->pb, 3, 1); /* is obj layer priority */
880
1c32039e7215 aspect ratio cleanup
michaelni
parents: 853
diff changeset
1681
887
19f5b8b7c6d5 fixing aspect
michaelni
parents: 880
diff changeset
1682 float_aspect_to_info(s, s->avctx->aspect_ratio);
880
1c32039e7215 aspect ratio cleanup
michaelni
parents: 853
diff changeset
1683
1c32039e7215 aspect ratio cleanup
michaelni
parents: 853
diff changeset
1684 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
1685 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
1686 {
b4bddbde44f3 aspect (ext. par too) support for h263 and mpeg4 (inc. build becouse of new vars)
al3x
parents: 667
diff changeset
1687 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
1688 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
1689 }
336
c56b45669214 export delay info
michaelni
parents: 335
diff changeset
1690
c56b45669214 export delay info
michaelni
parents: 335
diff changeset
1691 if(s->low_delay){
c56b45669214 export delay info
michaelni
parents: 335
diff changeset
1692 put_bits(&s->pb, 1, 1); /* vol control parameters= yes */
341
bf26081c373c avcodec_flush_buffers()
michaelni
parents: 339
diff changeset
1693 put_bits(&s->pb, 2, 1); /* chroma format YUV 420/YV12 */
336
c56b45669214 export delay info
michaelni
parents: 335
diff changeset
1694 put_bits(&s->pb, 1, s->low_delay);
c56b45669214 export delay info
michaelni
parents: 335
diff changeset
1695 put_bits(&s->pb, 1, 0); /* vbv parameters= no */
c56b45669214 export delay info
michaelni
parents: 335
diff changeset
1696 }else{
c56b45669214 export delay info
michaelni
parents: 335
diff changeset
1697 put_bits(&s->pb, 1, 0); /* vol control parameters= no */
c56b45669214 export delay info
michaelni
parents: 335
diff changeset
1698 }
c56b45669214 export delay info
michaelni
parents: 335
diff changeset
1699
263
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1700 put_bits(&s->pb, 2, RECT_SHAPE); /* vol shape= rectangle */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1701 put_bits(&s->pb, 1, 1); /* marker bit */
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
1702
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
1703 put_bits(&s->pb, 16, s->time_increment_resolution);
263
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1704 if (s->time_increment_bits < 1)
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1705 s->time_increment_bits = 1;
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1706 put_bits(&s->pb, 1, 1); /* marker bit */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1707 put_bits(&s->pb, 1, 0); /* fixed vop rate=no */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1708 put_bits(&s->pb, 1, 1); /* marker bit */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1709 put_bits(&s->pb, 13, s->width); /* vol width */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1710 put_bits(&s->pb, 1, 1); /* marker bit */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1711 put_bits(&s->pb, 13, s->height); /* vol height */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1712 put_bits(&s->pb, 1, 1); /* marker bit */
697
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
1713 put_bits(&s->pb, 1, s->progressive_sequence ? 0 : 1);
263
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1714 put_bits(&s->pb, 1, 1); /* obmc disable */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1715 if (vo_ver_id == 1) {
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1716 put_bits(&s->pb, 1, s->vol_sprite_usage=0); /* sprite enable */
942
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1717 }else{
263
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1718 put_bits(&s->pb, 2, s->vol_sprite_usage=0); /* sprite enable */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1719 }
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
1720
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
1721 s->quant_precision=5;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
1722 put_bits(&s->pb, 1, 0); /* not 8 bit == false */
599
b1a191202f96 mpeg4 mpeg quantizer encoding
michaelni
parents: 598
diff changeset
1723 put_bits(&s->pb, 1, s->mpeg_quant); /* quant type= (0=h263 style)*/
b1a191202f96 mpeg4 mpeg quantizer encoding
michaelni
parents: 598
diff changeset
1724 if(s->mpeg_quant) put_bits(&s->pb, 2, 0); /* no custom matrixes */
b1a191202f96 mpeg4 mpeg quantizer encoding
michaelni
parents: 598
diff changeset
1725
263
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1726 if (vo_ver_id != 1)
936
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
1727 put_bits(&s->pb, 1, s->quarter_sample);
263
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1728 put_bits(&s->pb, 1, 1); /* complexity estimation disable */
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1729 s->resync_marker= s->rtp_mode;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1730 put_bits(&s->pb, 1, s->resync_marker ? 0 : 1);/* resync marker disable */
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1731 put_bits(&s->pb, 1, s->data_partitioning ? 1 : 0);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1732 if(s->data_partitioning){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1733 put_bits(&s->pb, 1, 0); /* no rvlc */
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1734 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1735
263
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1736 if (vo_ver_id != 1){
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1737 put_bits(&s->pb, 1, 0); /* newpred */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1738 put_bits(&s->pb, 1, 0); /* reduced res vop */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1739 }
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1740 put_bits(&s->pb, 1, 0); /* scalability */
676
c3bdb00a98a9 dont store version for bit-exact tests
michaelni
parents: 674
diff changeset
1741
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1742 ff_mpeg4_stuffing(&s->pb);
676
c3bdb00a98a9 dont store version for bit-exact tests
michaelni
parents: 674
diff changeset
1743
c3bdb00a98a9 dont store version for bit-exact tests
michaelni
parents: 674
diff changeset
1744 /* user data */
1092
f59c3f66363b MpegEncContext.(i)dct_* -> DspContext.(i)dct_*
michaelni
parents: 1090
diff changeset
1745 if(!(s->flags & CODEC_FLAG_BITEXACT)){
676
c3bdb00a98a9 dont store version for bit-exact tests
michaelni
parents: 674
diff changeset
1746 put_bits(&s->pb, 16, 0);
c3bdb00a98a9 dont store version for bit-exact tests
michaelni
parents: 674
diff changeset
1747 put_bits(&s->pb, 16, 0x1B2); /* user_data */
1118
8248e652d64e simplified
al3x
parents: 1106
diff changeset
1748 put_string(&s->pb, LIBAVCODEC_IDENT);
676
c3bdb00a98a9 dont store version for bit-exact tests
michaelni
parents: 674
diff changeset
1749 ff_mpeg4_stuffing(&s->pb);
c3bdb00a98a9 dont store version for bit-exact tests
michaelni
parents: 674
diff changeset
1750 }
263
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1751 }
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1752
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1753 /* write mpeg4 VOP header */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1754 void mpeg4_encode_picture_header(MpegEncContext * s, int picture_number)
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1755 {
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
1756 int time_incr;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
1757 int time_div, time_mod;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
1758
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1759 if(s->pict_type==I_TYPE){
953
9eb066d6e0db mpeg4 header encoding bugfix
michaelni
parents: 945
diff changeset
1760 if(!(s->flags&CODEC_FLAG_GLOBAL_HEADER)){
942
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1761 mpeg4_encode_visual_object_header(s);
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1762 mpeg4_encode_vol_header(s, 0, 0);
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1763 }
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1764 mpeg4_encode_gop_header(s);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1765 }
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
1766
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
1767 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
1768
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
1769 //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
1770
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
1771 put_bits(&s->pb, 16, 0); /* vop header */
942
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
1772 put_bits(&s->pb, 16, VOP_STARTCODE); /* vop header */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1773 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
1774
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
1775 time_div= s->time/s->time_increment_resolution;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
1776 time_mod= s->time%s->time_increment_resolution;
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
1777 time_incr= time_div - s->last_time_base;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
1778 while(time_incr--)
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
1779 put_bits(&s->pb, 1, 1);
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
1780
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1781 put_bits(&s->pb, 1, 0);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1782
986e461dc072 Initial revision
glantau
parents:
diff changeset
1783 put_bits(&s->pb, 1, 1); /* marker */
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
1784 put_bits(&s->pb, s->time_increment_bits, time_mod); /* time increment */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1785 put_bits(&s->pb, 1, 1); /* marker */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1786 put_bits(&s->pb, 1, 1); /* vop coded */
263
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1787 if ( s->pict_type == P_TYPE
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1788 || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE)) {
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1789 put_bits(&s->pb, 1, s->no_rounding); /* rounding type */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1790 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1791 put_bits(&s->pb, 3, 0); /* intra dc VLC threshold */
697
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
1792 if(!s->progressive_sequence){
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
1793 put_bits(&s->pb, 1, s->top_field_first);
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
1794 put_bits(&s->pb, 1, s->alternate_scan);
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
1795 }
263
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1796 //FIXME sprite stuff
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1797
986e461dc072 Initial revision
glantau
parents:
diff changeset
1798 put_bits(&s->pb, 5, s->qscale);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1799
986e461dc072 Initial revision
glantau
parents:
diff changeset
1800 if (s->pict_type != I_TYPE)
986e461dc072 Initial revision
glantau
parents:
diff changeset
1801 put_bits(&s->pb, 3, s->f_code); /* fcode_for */
263
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1802 if (s->pict_type == B_TYPE)
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
1803 put_bits(&s->pb, 3, s->b_code); /* fcode_back */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1804 // printf("****frame %d\n", picture_number);
498
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
1805
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
1806 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
1807 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
1808 s->h_edge_pos= s->width;
5132a4ee50cd different edge positions fixed with edge emu / dr1
michaelni
parents: 575
diff changeset
1809 s->v_edge_pos= s->height;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1810 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1811
1070
6da5ae9ee199 more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents: 1068
diff changeset
1812 #endif //CONFIG_ENCODERS
6da5ae9ee199 more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents: 1068
diff changeset
1813
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
1814 /**
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
1815 * 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
1816 */
698
e050a053e259 h263_dc_scale() cleanup
michaelni
parents: 697
diff changeset
1817 static void change_qscale(MpegEncContext * s, int dquant)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1818 {
698
e050a053e259 h263_dc_scale() cleanup
michaelni
parents: 697
diff changeset
1819 s->qscale += dquant;
e050a053e259 h263_dc_scale() cleanup
michaelni
parents: 697
diff changeset
1820
e050a053e259 h263_dc_scale() cleanup
michaelni
parents: 697
diff changeset
1821 if (s->qscale < 1)
e050a053e259 h263_dc_scale() cleanup
michaelni
parents: 697
diff changeset
1822 s->qscale = 1;
e050a053e259 h263_dc_scale() cleanup
michaelni
parents: 697
diff changeset
1823 else if (s->qscale > 31)
e050a053e259 h263_dc_scale() cleanup
michaelni
parents: 697
diff changeset
1824 s->qscale = 31;
e050a053e259 h263_dc_scale() cleanup
michaelni
parents: 697
diff changeset
1825
498
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
1826 s->y_dc_scale= s->y_dc_scale_table[ s->qscale ];
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
1827 s->c_dc_scale= s->c_dc_scale_table[ s->qscale ];
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1828 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1829
1034
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
1830 /**
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
1831 * predicts the dc.
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
1832 * @param n block index (0-3 are luma, 4-5 are chroma)
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
1833 * @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
1834 * @param dir_ptr pointer to an integer where the prediction direction will be stored
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
1835 * @return the quantized predicted dc
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
1836 */
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
1837 static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, uint16_t **dc_val_ptr, int *dir_ptr)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1838 {
266
252444e5259b optimization
michaelni
parents: 265
diff changeset
1839 int a, b, c, wrap, pred, scale;
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
1840 uint16_t *dc_val;
469
a5dd4eae1f0c Revert previous bogus warning fix.
mellum
parents: 468
diff changeset
1841 int dummy;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1842
986e461dc072 Initial revision
glantau
parents:
diff changeset
1843 /* find prediction */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1844 if (n < 4) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1845 scale = s->y_dc_scale;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1846 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1847 scale = s->c_dc_scale;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1848 }
266
252444e5259b optimization
michaelni
parents: 265
diff changeset
1849 wrap= s->block_wrap[n];
252444e5259b optimization
michaelni
parents: 265
diff changeset
1850 dc_val = s->dc_val[0] + s->block_index[n];
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1851
986e461dc072 Initial revision
glantau
parents:
diff changeset
1852 /* B C
986e461dc072 Initial revision
glantau
parents:
diff changeset
1853 * A X
986e461dc072 Initial revision
glantau
parents:
diff changeset
1854 */
266
252444e5259b optimization
michaelni
parents: 265
diff changeset
1855 a = dc_val[ - 1];
252444e5259b optimization
michaelni
parents: 265
diff changeset
1856 b = dc_val[ - 1 - wrap];
252444e5259b optimization
michaelni
parents: 265
diff changeset
1857 c = dc_val[ - wrap];
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1858
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
1859 /* 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
1860 if(s->first_slice_line && n!=3){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
1861 if(n!=2) b=c= 1024;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
1862 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
1863 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
1864 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
1865 if(n==0 || n==4 || n==5)
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
1866 b=1024;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
1867 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
1868
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1869 if (abs(a - b) < abs(b - c)) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1870 pred = c;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1871 *dir_ptr = 1; /* top */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1872 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1873 pred = a;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1874 *dir_ptr = 0; /* left */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1875 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1876 /* we assume pred is positive */
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1877 #ifdef ARCH_X86
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1878 asm volatile (
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1879 "xorl %%edx, %%edx \n\t"
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1880 "mul %%ecx \n\t"
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1881 : "=d" (pred), "=a"(dummy)
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1882 : "a" (pred + (scale >> 1)), "c" (inverse[scale])
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1883 );
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1884 #else
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1885 pred = (pred + (scale >> 1)) / scale;
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1886 #endif
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1887
986e461dc072 Initial revision
glantau
parents:
diff changeset
1888 /* prepare address for prediction update */
266
252444e5259b optimization
michaelni
parents: 265
diff changeset
1889 *dc_val_ptr = &dc_val[0];
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1890
986e461dc072 Initial revision
glantau
parents:
diff changeset
1891 return pred;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1892 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1893
1034
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
1894 /**
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
1895 * predicts the ac.
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
1896 * @param n block index (0-3 are luma, 4-5 are chroma)
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
1897 * @param dir the ac prediction direction
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
1898 */
1008
fb6cbb8a04a3 fixing DCTELEM != short
michaelni
parents: 999
diff changeset
1899 void mpeg4_pred_ac(MpegEncContext * s, DCTELEM *block, int n,
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1900 int dir)
986e461dc072 Initial revision
glantau
parents:
diff changeset
1901 {
266
252444e5259b optimization
michaelni
parents: 265
diff changeset
1902 int i;
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
1903 int16_t *ac_val, *ac_val1;
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
1904 int8_t * const qscale_table= s->current_picture.qscale_table;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1905
986e461dc072 Initial revision
glantau
parents:
diff changeset
1906 /* find prediction */
266
252444e5259b optimization
michaelni
parents: 265
diff changeset
1907 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1908 ac_val1 = ac_val;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1909 if (s->ac_pred) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1910 if (dir == 0) {
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
1911 const int xy= s->mb_x-1 + s->mb_y*s->mb_width;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1912 /* left prediction */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1913 ac_val -= 16;
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
1914
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
1915 if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
1916 /* same qscale */
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
1917 for(i=1;i<8;i++) {
1092
f59c3f66363b MpegEncContext.(i)dct_* -> DspContext.(i)dct_*
michaelni
parents: 1090
diff changeset
1918 block[s->dsp.idct_permutation[i<<3]] += ac_val[i];
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
1919 }
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
1920 }else{
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
1921 /* different qscale, we must rescale */
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
1922 for(i=1;i<8;i++) {
1092
f59c3f66363b MpegEncContext.(i)dct_* -> DspContext.(i)dct_*
michaelni
parents: 1090
diff changeset
1923 block[s->dsp.idct_permutation[i<<3]] += ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale);
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
1924 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1925 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1926 } else {
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
1927 const int xy= s->mb_x + s->mb_y*s->mb_width - s->mb_width;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1928 /* top prediction */
266
252444e5259b optimization
michaelni
parents: 265
diff changeset
1929 ac_val -= 16 * s->block_wrap[n];
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
1930
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
1931 if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
1932 /* same qscale */
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
1933 for(i=1;i<8;i++) {
1092
f59c3f66363b MpegEncContext.(i)dct_* -> DspContext.(i)dct_*
michaelni
parents: 1090
diff changeset
1934 block[s->dsp.idct_permutation[i]] += ac_val[i + 8];
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
1935 }
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
1936 }else{
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
1937 /* different qscale, we must rescale */
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
1938 for(i=1;i<8;i++) {
1092
f59c3f66363b MpegEncContext.(i)dct_* -> DspContext.(i)dct_*
michaelni
parents: 1090
diff changeset
1939 block[s->dsp.idct_permutation[i]] += ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale);
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
1940 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1941 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1942 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1943 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1944 /* left copy */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1945 for(i=1;i<8;i++)
1092
f59c3f66363b MpegEncContext.(i)dct_* -> DspContext.(i)dct_*
michaelni
parents: 1090
diff changeset
1946 ac_val1[i ] = block[s->dsp.idct_permutation[i<<3]];
591
d3f374218030 fixing mpeg4 mpeg quantizers
michaelni
parents: 582
diff changeset
1947
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1948 /* top copy */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1949 for(i=1;i<8;i++)
1092
f59c3f66363b MpegEncContext.(i)dct_* -> DspContext.(i)dct_*
michaelni
parents: 1090
diff changeset
1950 ac_val1[8 + i] = block[s->dsp.idct_permutation[i ]];
591
d3f374218030 fixing mpeg4 mpeg quantizers
michaelni
parents: 582
diff changeset
1951
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1952 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1953
1070
6da5ae9ee199 more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents: 1068
diff changeset
1954 #ifdef CONFIG_ENCODERS
6da5ae9ee199 more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents: 1068
diff changeset
1955
1008
fb6cbb8a04a3 fixing DCTELEM != short
michaelni
parents: 999
diff changeset
1956 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
1957 int dir)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1958 {
266
252444e5259b optimization
michaelni
parents: 265
diff changeset
1959 int i;
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
1960 int16_t *ac_val;
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
1961 int8_t * const qscale_table= s->current_picture.qscale_table;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1962
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1963 /* find prediction */
266
252444e5259b optimization
michaelni
parents: 265
diff changeset
1964 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
1965
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1966 if (dir == 0) {
692
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
1967 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
1968 /* left prediction */
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1969 ac_val -= 16;
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
1970 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
1971 /* same qscale */
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
1972 for(i=1;i<8;i++) {
1092
f59c3f66363b MpegEncContext.(i)dct_* -> DspContext.(i)dct_*
michaelni
parents: 1090
diff changeset
1973 block[s->dsp.idct_permutation[i<<3]] -= ac_val[i];
692
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
1974 }
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
1975 }else{
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
1976 /* different qscale, we must rescale */
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
1977 for(i=1;i<8;i++) {
1092
f59c3f66363b MpegEncContext.(i)dct_* -> DspContext.(i)dct_*
michaelni
parents: 1090
diff changeset
1978 block[s->dsp.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
1979 }
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1980 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1981 } else {
692
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
1982 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
1983 /* top prediction */
266
252444e5259b optimization
michaelni
parents: 265
diff changeset
1984 ac_val -= 16 * s->block_wrap[n];
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
1985 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
1986 /* same qscale */
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
1987 for(i=1;i<8;i++) {
1092
f59c3f66363b MpegEncContext.(i)dct_* -> DspContext.(i)dct_*
michaelni
parents: 1090
diff changeset
1988 block[s->dsp.idct_permutation[i]] -= ac_val[i + 8];
692
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
1989 }
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
1990 }else{
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
1991 /* different qscale, we must rescale */
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
1992 for(i=1;i<8;i++) {
1092
f59c3f66363b MpegEncContext.(i)dct_* -> DspContext.(i)dct_*
michaelni
parents: 1090
diff changeset
1993 block[s->dsp.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
1994 }
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1995 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1996 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1997 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1998
1034
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
1999 /**
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
2000 * encodes the dc value.
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
2001 * @param n block index (0-3 are luma, 4-5 are chroma)
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
2002 */
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2003 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
2004 {
293
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
2005 #if 1
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2006 // if(level<-255 || level>255) printf("dc overflow\n");
293
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
2007 level+=256;
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
2008 if (n < 4) {
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
2009 /* luminance */
1013
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1008
diff changeset
2010 put_bits(s, uni_DCtab_lum_len[level], uni_DCtab_lum_bits[level]);
293
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
2011 } else {
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
2012 /* chrominance */
1013
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1008
diff changeset
2013 put_bits(s, uni_DCtab_chrom_len[level], uni_DCtab_chrom_bits[level]);
293
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
2014 }
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
2015 #else
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
2016 int size, v;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2017 /* find number of bits */
986e461dc072 Initial revision
glantau
parents:
diff changeset
2018 size = 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2019 v = abs(level);
986e461dc072 Initial revision
glantau
parents:
diff changeset
2020 while (v) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
2021 v >>= 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2022 size++;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2023 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
2024
986e461dc072 Initial revision
glantau
parents:
diff changeset
2025 if (n < 4) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
2026 /* luminance */
986e461dc072 Initial revision
glantau
parents:
diff changeset
2027 put_bits(&s->pb, DCtab_lum[size][1], DCtab_lum[size][0]);
986e461dc072 Initial revision
glantau
parents:
diff changeset
2028 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
2029 /* chrominance */
986e461dc072 Initial revision
glantau
parents:
diff changeset
2030 put_bits(&s->pb, DCtab_chrom[size][1], DCtab_chrom[size][0]);
986e461dc072 Initial revision
glantau
parents:
diff changeset
2031 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
2032
986e461dc072 Initial revision
glantau
parents:
diff changeset
2033 /* encode remaining bits */
986e461dc072 Initial revision
glantau
parents:
diff changeset
2034 if (size > 0) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
2035 if (level < 0)
986e461dc072 Initial revision
glantau
parents:
diff changeset
2036 level = (-level) ^ ((1 << size) - 1);
986e461dc072 Initial revision
glantau
parents:
diff changeset
2037 put_bits(&s->pb, size, level);
986e461dc072 Initial revision
glantau
parents:
diff changeset
2038 if (size > 8)
986e461dc072 Initial revision
glantau
parents:
diff changeset
2039 put_bits(&s->pb, 1, 1);
986e461dc072 Initial revision
glantau
parents:
diff changeset
2040 }
293
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
2041 #endif
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2042 }
1070
6da5ae9ee199 more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents: 1068
diff changeset
2043
1034
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
2044 /**
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
2045 * encodes a 8x8 block
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
2046 * @param n block index (0-3 are luma, 4-5 are chroma)
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
2047 */
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
2048 static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n, int intra_dc,
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
2049 uint8_t *scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2050 {
751
cbe316f082bc warning fixes
michaelni
parents: 747
diff changeset
2051 int i, last_non_zero;
cbe316f082bc warning fixes
michaelni
parents: 747
diff changeset
2052 #if 0 //variables for the outcommented version
cbe316f082bc warning fixes
michaelni
parents: 747
diff changeset
2053 int code, sign, last;
cbe316f082bc warning fixes
michaelni
parents: 747
diff changeset
2054 #endif
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2055 const RLTable *rl;
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
2056 uint32_t *bits_tab;
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
2057 uint8_t *len_tab;
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
2058 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
2059
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream 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 if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2061 /* mpeg4 based DC predictor */
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2062 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
2063 if(last_index<1) return;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2064 i = 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2065 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
2066 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
2067 len_tab = uni_mpeg4_intra_rl_len;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2068 } 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
2069 if(last_index<0) return;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2070 i = 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2071 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
2072 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
2073 len_tab = uni_mpeg4_inter_rl_len;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2074 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
2075
986e461dc072 Initial revision
glantau
parents:
diff changeset
2076 /* AC coefs */
986e461dc072 Initial revision
glantau
parents:
diff changeset
2077 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
2078 #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
2079 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
2080 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
2081 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
2082 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
2083 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
2084 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
2085 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
2086 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
2087 }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
2088 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
2089 }
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream 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 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
2091 }
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
2092 }
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream 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 /*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
2094 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
2095 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
2096 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
2097 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
2098 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
2099 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
2100 }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
2101 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
2102 }
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
2103 }
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
2104 #else
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2105 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
2106 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
2107 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
2108 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
2109 int run = i - last_non_zero - 1;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2110 last = (i == last_index);
986e461dc072 Initial revision
glantau
parents:
diff changeset
2111 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
2112 level = slevel;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2113 if (level < 0) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
2114 sign = 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2115 level = -level;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2116 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
2117 code = get_rl_index(rl, last, run, level);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2118 put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2119 if (code == rl->n) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
2120 int level1, run1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2121 level1 = level - rl->max_level[last][run];
986e461dc072 Initial revision
glantau
parents:
diff changeset
2122 if (level1 < 1)
986e461dc072 Initial revision
glantau
parents:
diff changeset
2123 goto esc2;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2124 code = get_rl_index(rl, last, run, level1);
986e461dc072 Initial revision
glantau
parents:
diff changeset
2125 if (code == rl->n) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
2126 esc2:
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2127 put_bits(ac_pb, 1, 1);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2128 if (level > MAX_LEVEL)
986e461dc072 Initial revision
glantau
parents:
diff changeset
2129 goto esc3;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2130 run1 = run - rl->max_run[last][level] - 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2131 if (run1 < 0)
986e461dc072 Initial revision
glantau
parents:
diff changeset
2132 goto esc3;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2133 code = get_rl_index(rl, last, run1, level);
986e461dc072 Initial revision
glantau
parents:
diff changeset
2134 if (code == rl->n) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
2135 esc3:
986e461dc072 Initial revision
glantau
parents:
diff changeset
2136 /* third escape */
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2137 put_bits(ac_pb, 1, 1);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2138 put_bits(ac_pb, 1, last);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2139 put_bits(ac_pb, 6, run);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2140 put_bits(ac_pb, 1, 1);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2141 put_bits(ac_pb, 12, slevel & 0xfff);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2142 put_bits(ac_pb, 1, 1);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2143 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
2144 /* second escape */
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2145 put_bits(ac_pb, 1, 0);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2146 put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2147 put_bits(ac_pb, 1, sign);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2148 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
2149 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
2150 /* first escape */
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2151 put_bits(ac_pb, 1, 0);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2152 put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2153 put_bits(ac_pb, 1, sign);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2154 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
2155 } else {
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2156 put_bits(ac_pb, 1, sign);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2157 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
2158 last_non_zero = i;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2159 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
2160 }
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
2161 #endif
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2162 }
936
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2163
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2164 static inline int mpeg4_get_block_length(MpegEncContext * s, DCTELEM * block, int n, int intra_dc,
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
2165 uint8_t *scan_table)
936
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2166 {
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2167 int i, last_non_zero;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2168 const RLTable *rl;
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
2169 uint8_t *len_tab;
936
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2170 const int last_index = s->block_last_index[n];
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2171 int len=0;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2172
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2173 if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2174 /* mpeg4 based DC predictor */
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2175 //mpeg4_encode_dc(dc_pb, intra_dc, n); //FIXME
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2176 if(last_index<1) return len;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2177 i = 1;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2178 rl = &rl_intra;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2179 len_tab = uni_mpeg4_intra_rl_len;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2180 } else {
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2181 if(last_index<0) return 0;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2182 i = 0;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2183 rl = &rl_inter;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2184 len_tab = uni_mpeg4_inter_rl_len;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2185 }
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2186
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2187 /* AC coefs */
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2188 last_non_zero = i - 1;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2189 for (; i < last_index; i++) {
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2190 int level = block[ scan_table[i] ];
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2191 if (level) {
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2192 int run = i - last_non_zero - 1;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2193 level+=64;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2194 if((level&(~127)) == 0){
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2195 const int index= UNI_MPEG4_ENC_INDEX(0, run, level);
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2196 len += len_tab[index];
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2197 }else{ //ESC3
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2198 len += 7+2+1+6+1+12+1;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2199 }
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2200 last_non_zero = i;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2201 }
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2202 }
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2203 /*if(i<=last_index)*/{
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2204 int level = block[ scan_table[i] ];
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2205 int run = i - last_non_zero - 1;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2206 level+=64;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2207 if((level&(~127)) == 0){
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2208 const int index= UNI_MPEG4_ENC_INDEX(1, run, level);
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2209 len += len_tab[index];
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2210 }else{ //ESC3
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2211 len += 7+2+1+6+1+12+1;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2212 }
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2213 }
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2214
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2215 return len;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2216 }
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2217
815
78accc54493b put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents: 770
diff changeset
2218 #endif
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2219
986e461dc072 Initial revision
glantau
parents:
diff changeset
2220
986e461dc072 Initial revision
glantau
parents:
diff changeset
2221 /***********************************************/
986e461dc072 Initial revision
glantau
parents:
diff changeset
2222 /* decoding */
986e461dc072 Initial revision
glantau
parents:
diff changeset
2223
986e461dc072 Initial revision
glantau
parents:
diff changeset
2224 static VLC intra_MCBPC_vlc;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2225 static VLC inter_MCBPC_vlc;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2226 static VLC cbpy_vlc;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2227 static VLC mv_vlc;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2228 static VLC dc_lum, dc_chrom;
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
2229 static VLC sprite_trajectory;
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2230 static VLC mb_type_b_vlc;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2231
986e461dc072 Initial revision
glantau
parents:
diff changeset
2232 void init_vlc_rl(RLTable *rl)
986e461dc072 Initial revision
glantau
parents:
diff changeset
2233 {
542
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2234 int i, q;
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2235
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2236 init_vlc(&rl->vlc, 9, rl->n + 1,
986e461dc072 Initial revision
glantau
parents:
diff changeset
2237 &rl->table_vlc[0][1], 4, 2,
986e461dc072 Initial revision
glantau
parents:
diff changeset
2238 &rl->table_vlc[0][0], 4, 2);
542
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2239
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2240
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2241 for(q=0; q<32; q++){
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2242 int qmul= q*2;
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2243 int qadd= (q-1)|1;
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2244
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2245 if(q==0){
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2246 qmul=1;
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2247 qadd=0;
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2248 }
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2249
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2250 rl->rl_vlc[q]= av_malloc(rl->vlc.table_size*sizeof(RL_VLC_ELEM));
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2251 for(i=0; i<rl->vlc.table_size; i++){
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2252 int code= rl->vlc.table[i][0];
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2253 int len = rl->vlc.table[i][1];
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2254 int level, run;
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2255
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2256 if(len==0){ // illegal code
563
61442627f857 fixes fire.avi & subtitles.avi
michaelni
parents: 549
diff changeset
2257 run= 66;
542
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2258 level= MAX_LEVEL;
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2259 }else if(len<0){ //more bits needed
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2260 run= 0;
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2261 level= code;
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2262 }else{
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2263 if(code==rl->n){ //esc
563
61442627f857 fixes fire.avi & subtitles.avi
michaelni
parents: 549
diff changeset
2264 run= 66;
542
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2265 level= 0;
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2266 }else{
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2267 run= rl->table_run [code] + 1;
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2268 level= rl->table_level[code] * qmul + qadd;
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2269 if(code >= rl->last) run+=192;
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2270 }
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2271 }
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2272 rl->rl_vlc[q][i].len= len;
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2273 rl->rl_vlc[q][i].level= level;
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2274 rl->rl_vlc[q][i].run= run;
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2275 }
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2276 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2277 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
2278
986e461dc072 Initial revision
glantau
parents:
diff changeset
2279 /* init vlcs */
986e461dc072 Initial revision
glantau
parents:
diff changeset
2280
986e461dc072 Initial revision
glantau
parents:
diff changeset
2281 /* XXX: find a better solution to handle static init */
986e461dc072 Initial revision
glantau
parents:
diff changeset
2282 void h263_decode_init_vlc(MpegEncContext *s)
986e461dc072 Initial revision
glantau
parents:
diff changeset
2283 {
986e461dc072 Initial revision
glantau
parents:
diff changeset
2284 static int done = 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2285
986e461dc072 Initial revision
glantau
parents:
diff changeset
2286 if (!done) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
2287 done = 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2288
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
2289 init_vlc(&intra_MCBPC_vlc, INTRA_MCBPC_VLC_BITS, 8,
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2290 intra_MCBPC_bits, 1, 1,
986e461dc072 Initial revision
glantau
parents:
diff changeset
2291 intra_MCBPC_code, 1, 1);
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
2292 init_vlc(&inter_MCBPC_vlc, INTER_MCBPC_VLC_BITS, 25,
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2293 inter_MCBPC_bits, 1, 1,
986e461dc072 Initial revision
glantau
parents:
diff changeset
2294 inter_MCBPC_code, 1, 1);
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
2295 init_vlc(&cbpy_vlc, CBPY_VLC_BITS, 16,
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2296 &cbpy_tab[0][1], 2, 1,
986e461dc072 Initial revision
glantau
parents:
diff changeset
2297 &cbpy_tab[0][0], 2, 1);
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
2298 init_vlc(&mv_vlc, MV_VLC_BITS, 33,
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2299 &mvtab[0][1], 2, 1,
986e461dc072 Initial revision
glantau
parents:
diff changeset
2300 &mvtab[0][0], 2, 1);
986e461dc072 Initial revision
glantau
parents:
diff changeset
2301 init_rl(&rl_inter);
986e461dc072 Initial revision
glantau
parents:
diff changeset
2302 init_rl(&rl_intra);
1132
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
2303 init_rl(&rvlc_rl_inter);
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
2304 init_rl(&rvlc_rl_intra);
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
2305 init_rl(&rl_intra_aic);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2306 init_vlc_rl(&rl_inter);
986e461dc072 Initial revision
glantau
parents:
diff changeset
2307 init_vlc_rl(&rl_intra);
1132
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
2308 init_vlc_rl(&rvlc_rl_inter);
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
2309 init_vlc_rl(&rvlc_rl_intra);
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
2310 init_vlc_rl(&rl_intra_aic);
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
2311 init_vlc(&dc_lum, DC_VLC_BITS, 10 /* 13 */,
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2312 &DCtab_lum[0][1], 2, 1,
986e461dc072 Initial revision
glantau
parents:
diff changeset
2313 &DCtab_lum[0][0], 2, 1);
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
2314 init_vlc(&dc_chrom, DC_VLC_BITS, 10 /* 13 */,
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2315 &DCtab_chrom[0][1], 2, 1,
986e461dc072 Initial revision
glantau
parents:
diff changeset
2316 &DCtab_chrom[0][0], 2, 1);
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
2317 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
2318 &sprite_trajectory_tab[0][1], 4, 2,
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
2319 &sprite_trajectory_tab[0][0], 4, 2);
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
2320 init_vlc(&mb_type_b_vlc, MB_TYPE_B_VLC_BITS, 4,
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2321 &mb_type_b_tab[0][1], 2, 1,
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2322 &mb_type_b_tab[0][0], 2, 1);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2323 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
2324 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
2325
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2326 /**
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2327 * 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
2328 */
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2329 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
2330 if (s->height <= 400)
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2331 return 1;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2332 else if (s->height <= 800)
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2333 return 2;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2334 else
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2335 return 4;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2336 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2337
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2338 /**
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2339 * decodes the group of blocks header.
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2340 * @return <0 if an error occured
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 static int h263_decode_gob_header(MpegEncContext *s)
162
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
2343 {
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
2344 unsigned int val, gfid;
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2345 int left;
162
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
2346
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
2347 /* Check for GOB Start Code */
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
2348 val = show_bits(&s->gb, 16);
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2349 if(val)
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2350 return -1;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2351
162
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
2352 /* 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
2353 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
2354 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
2355 //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
2356 for(;left>13; left--){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2357 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
2358 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2359 if(left<=13)
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2360 return -1;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2361
162
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
2362 #ifdef DEBUG
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2363 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
2364 #endif
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2365 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
2366 gfid = get_bits(&s->gb, 2); /* GFID */
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2367 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
2368 if(s->qscale==0)
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2369 return -1;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2370 s->mb_x= 0;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2371 s->mb_y= s->gob_index* s->gob_number;
162
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
2372 #ifdef DEBUG
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2373 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
2374 #endif
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
2375 return 0;
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
2376 }
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
2377
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2378 static inline void memsetw(short *tab, int val, int n)
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2379 {
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2380 int i;
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2381 for(i=0;i<n;i++)
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2382 tab[i] = val;
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2383 }
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2384
1070
6da5ae9ee199 more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents: 1068
diff changeset
2385 #ifdef CONFIG_ENCODERS
6da5ae9ee199 more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents: 1068
diff changeset
2386
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2387 void ff_mpeg4_init_partitions(MpegEncContext *s)
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2388 {
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2389 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
2390 init_put_bits(&s->pb2 , s->pb2_buffer , PB_BUFFER_SIZE, NULL, NULL);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2391 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2392
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2393 void ff_mpeg4_merge_partitions(MpegEncContext *s)
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2394 {
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2395 const int pb2_len = get_bit_count(&s->pb2 );
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2396 const int tex_pb_len= get_bit_count(&s->tex_pb);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2397 const int bits= get_bit_count(&s->pb);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2398
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2399 if(s->pict_type==I_TYPE){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2400 put_bits(&s->pb, 19, DC_MARKER);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2401 s->misc_bits+=19 + pb2_len + bits - s->last_bits;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2402 s->i_tex_bits+= tex_pb_len;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2403 }else{
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2404 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
2405 s->misc_bits+=17 + pb2_len;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2406 s->mv_bits+= bits - s->last_bits;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2407 s->p_tex_bits+= tex_pb_len;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2408 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2409
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2410 flush_put_bits(&s->pb2);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2411 flush_put_bits(&s->tex_pb);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2412
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2413 ff_copy_bits(&s->pb, s->pb2_buffer , pb2_len);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2414 ff_copy_bits(&s->pb, s->tex_pb_buffer, tex_pb_len);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2415 s->last_bits= get_bit_count(&s->pb);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2416 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2417
1070
6da5ae9ee199 more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents: 1068
diff changeset
2418 #endif //CONFIG_ENCODERS
6da5ae9ee199 more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents: 1068
diff changeset
2419
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2420 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
2421 switch(s->pict_type){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2422 case I_TYPE:
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2423 return 16;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2424 case P_TYPE:
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2425 case S_TYPE:
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2426 return s->f_code+15;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2427 case B_TYPE:
847
f3c369b8ddca reversing header game
michaelni
parents: 821
diff changeset
2428 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
2429 default:
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2430 return -1;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2431 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2432 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2433
1070
6da5ae9ee199 more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents: 1068
diff changeset
2434 #ifdef CONFIG_ENCODERS
6da5ae9ee199 more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents: 1068
diff changeset
2435
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2436 void ff_mpeg4_encode_video_packet_header(MpegEncContext *s)
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2437 {
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2438 int mb_num_bits= av_log2(s->mb_num - 1) + 1;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2439
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2440 ff_mpeg4_stuffing(&s->pb);
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2441 put_bits(&s->pb, ff_mpeg4_get_video_packet_prefix_length(s), 0);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2442 put_bits(&s->pb, 1, 1);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2443
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2444 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
2445 put_bits(&s->pb, s->quant_precision, s->qscale);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2446 put_bits(&s->pb, 1, 0); /* no HEC */
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2447 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2448
1070
6da5ae9ee199 more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents: 1068
diff changeset
2449 #endif //CONFIG_ENCODERS
6da5ae9ee199 more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents: 1068
diff changeset
2450
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2451 /**
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2452 * 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
2453 * @return 0 if not
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2454 */
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2455 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
2456 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
2457
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2458 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
2459 return 0;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2460 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2461
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
2462 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
2463 int v= show_bits(&s->gb, 8);
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2464 v|= 0x7F >> (7-(bits_count&7));
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2465
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2466 if(v==0x7F)
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2467 return 1;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2468 }else{
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2469 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
2470 int len;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2471 GetBitContext gb= s->gb;
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 skip_bits(&s->gb, 1);
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2474 align_get_bits(&s->gb);
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2475
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2476 for(len=0; len<32; len++){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2477 if(get_bits1(&s->gb)) break;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2478 }
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 s->gb= gb;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2481
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2482 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
2483 return 1;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2484 }
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 return 0;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2487 }
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 /**
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2490 * decodes the next video packet.
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2491 * @return <0 if something went wrong
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 static int mpeg4_decode_video_packet_header(MpegEncContext *s)
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2494 {
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2495 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
2496 int header_extension=0, mb_num, len;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2497
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2498 /* 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
2499 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
2500
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2501 for(len=0; len<32; len++){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2502 if(get_bits1(&s->gb)) break;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2503 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2504
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2505 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
2506 printf("marker does not match f_code\n");
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2507 return -1;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2508 }
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2509
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2510 if(s->shape != RECT_SHAPE){
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2511 header_extension= get_bits1(&s->gb);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2512 //FIXME more stuff here
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2513 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2514
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2515 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
2516 if(mb_num>=s->mb_num){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2517 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
2518 return -1;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2519 }
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2520 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
2521 s->mb_y= mb_num / s->mb_width;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2522
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2523 if(s->shape != BIN_ONLY_SHAPE){
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2524 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
2525 if(qscale)
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2526 s->qscale= qscale;
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2527 }
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2528
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2529 if(s->shape == RECT_SHAPE){
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2530 header_extension= get_bits1(&s->gb);
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2531 }
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2532 if(header_extension){
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2533 int time_increment;
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2534 int time_incr=0;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2535
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2536 while (get_bits1(&s->gb) != 0)
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2537 time_incr++;
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2538
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2539 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
2540 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
2541 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
2542
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2543 skip_bits(&s->gb, 2); /* vop coding type */
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2544 //FIXME not rect stuff here
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2545
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2546 if(s->shape != BIN_ONLY_SHAPE){
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2547 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
2548 //FIXME dont just ignore everything
821
f5f2e162331c hopefully fixing sprite_warping_points==0
michaelni
parents: 815
diff changeset
2549 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
2550 mpeg4_decode_sprite_trajectory(s);
660
b8e268337a1d parsing resync header extension support
michaelni
parents: 659
diff changeset
2551 fprintf(stderr, "untested\n");
290
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
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2554 //FIXME reduced res stuff here
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2555
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2556 if (s->pict_type != I_TYPE) {
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2557 int f_code = get_bits(&s->gb, 3); /* fcode_for */
660
b8e268337a1d parsing resync header extension support
michaelni
parents: 659
diff changeset
2558 if(f_code==0){
b8e268337a1d parsing resync header extension support
michaelni
parents: 659
diff changeset
2559 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
2560 }
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2561 }
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2562 if (s->pict_type == B_TYPE) {
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2563 int b_code = get_bits(&s->gb, 3);
660
b8e268337a1d parsing resync header extension support
michaelni
parents: 659
diff changeset
2564 if(b_code==0){
b8e268337a1d parsing resync header extension support
michaelni
parents: 659
diff changeset
2565 printf("Error, video packet header damaged (b_code=0)\n");
b8e268337a1d parsing resync header extension support
michaelni
parents: 659
diff changeset
2566 }
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 }
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2570 //FIXME new-pred stuff
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2571
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2572 //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
2573
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2574 return 0;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2575 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2576
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2577 void ff_mpeg4_clean_buffers(MpegEncContext *s)
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2578 {
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2579 int c_wrap, c_xy, l_wrap, l_xy;
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2580
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2581 l_wrap= s->block_wrap[0];
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2582 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
2583 c_wrap= s->block_wrap[4];
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2584 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
2585
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2586 #if 0
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2587 /* clean DC */
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2588 memsetw(s->dc_val[0] + l_xy, 1024, l_wrap*2+1);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2589 memsetw(s->dc_val[1] + c_xy, 1024, c_wrap+1);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2590 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
2591 #endif
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2592
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2593 /* clean AC */
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
2594 memset(s->ac_val[0] + l_xy, 0, (l_wrap*2+1)*16*sizeof(int16_t));
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
2595 memset(s->ac_val[1] + c_xy, 0, (c_wrap +1)*16*sizeof(int16_t));
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
2596 memset(s->ac_val[2] + c_xy, 0, (c_wrap +1)*16*sizeof(int16_t));
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2597
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2598 /* clean MV */
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2599 // we cant clear the MVs as they might be needed by a b frame
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
2600 // memset(s->motion_val + l_xy, 0, (l_wrap*2+1)*2*sizeof(int16_t));
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
2601 // memset(s->motion_val, 0, 2*sizeof(int16_t)*(2 + s->mb_width*2)*(2 + s->mb_height*2));
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2602 s->last_mv[0][0][0]=
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2603 s->last_mv[0][0][1]=
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2604 s->last_mv[1][0][0]=
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2605 s->last_mv[1][0][1]= 0;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2606 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2607
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2608 /**
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2609 * 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
2610 * @return <0 if no resync found
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2611 */
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2612 int ff_h263_resync(MpegEncContext *s){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2613 int left, ret;
453
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 if(s->codec_id==CODEC_ID_MPEG4)
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2616 skip_bits1(&s->gb);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2617
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2618 align_get_bits(&s->gb);
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2619
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2620 if(show_bits(&s->gb, 16)==0){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2621 if(s->codec_id==CODEC_ID_MPEG4)
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2622 ret= mpeg4_decode_video_packet_header(s);
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2623 else
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2624 ret= h263_decode_gob_header(s);
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2625 if(ret>=0)
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2626 return 0;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2627 }
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2628 //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
2629 s->gb= s->last_resync_gb;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2630 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
2631 left= s->gb.size_in_bits - get_bits_count(&s->gb);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2632
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2633 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
2634 if(show_bits(&s->gb, 16)==0){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2635 GetBitContext bak= s->gb;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2636
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2637 if(s->codec_id==CODEC_ID_MPEG4)
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2638 ret= mpeg4_decode_video_packet_header(s);
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2639 else
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2640 ret= h263_decode_gob_header(s);
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2641 if(ret>=0)
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2642 return 0;
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 s->gb= bak;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2645 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2646 skip_bits(&s->gb, 8);
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2647 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2648
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2649 return -1;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2650 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2651
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2652 /**
1034
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
2653 * gets the average motion vector for a GMC MB.
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2654 * @param n either 0 for the x component or 1 for y
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2655 * @returns the average MV for a GMC MB
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2656 */
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2657 static inline int get_amv(MpegEncContext *s, int n){
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2658 int x, y, mb_v, sum, dx, dy, shift;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2659 int len = 1 << (s->f_code + 4);
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2660 const int a= s->sprite_warping_accuracy;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2661
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2662 if(s->real_sprite_warping_points==1){
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2663 if(s->divx_version==500 && s->divx_build==413)
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2664 sum= s->sprite_offset[0][n] / (1<<(a - s->quarter_sample));
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2665 else
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2666 sum= RSHIFT(s->sprite_offset[0][n]<<s->quarter_sample, a);
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2667 }else{
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2668 dx= s->sprite_delta[n][0];
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2669 dy= s->sprite_delta[n][1];
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2670 shift= s->sprite_shift[0];
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2671 if(n) dy -= 1<<(shift + a + 1);
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2672 else dx -= 1<<(shift + a + 1);
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2673 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
2674
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2675 sum=0;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2676 for(y=0; y<16; y++){
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2677 int v;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2678
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2679 v= mb_v + dy*y;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2680 //XXX FIXME optimize
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2681 for(x=0; x<16; x++){
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2682 sum+= v>>shift;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2683 v+= dx;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2684 }
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2685 }
999
74dc4105e147 average motion vector rounding like the reference says and not what the standard says
michaelni
parents: 953
diff changeset
2686 sum= RSHIFT(sum, a+8-s->quarter_sample);
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2687 }
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2688
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2689 if (sum < -len) sum= -len;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2690 else if (sum >= len) sum= len-1;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2691
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2692 return sum;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2693 }
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2694
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2695 /**
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2696 * decodes first partition.
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2697 * @return number of MBs decoded or <0 if an error occured
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2698 */
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2699 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
2700 int mb_num;
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
2701 static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2702
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2703 /* decode first partition */
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2704 mb_num=0;
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2705 s->first_slice_line=1;
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2706 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
2707 ff_init_block_index(s);
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2708 for(; s->mb_x<s->mb_width; s->mb_x++){
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2709 const int xy= s->mb_x + s->mb_y*s->mb_width;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2710 int cbpc;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2711 int dir=0;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2712
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2713 mb_num++;
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2714 ff_update_block_index(s);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2715 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
2716 s->first_slice_line=0;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2717
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2718 if(s->mb_x==0) PRINT_MB_TYPE("\n");
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2719
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2720 if(s->pict_type==I_TYPE){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2721 int i;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2722
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2723 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
2724 return mb_num-1;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2725 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2726
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2727 PRINT_MB_TYPE("I");
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
2728 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
2729 if (cbpc < 0){
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2730
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2731 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
2732 return -1;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2733 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2734 s->cbp_table[xy]= cbpc & 3;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2735 s->mb_type[xy]= MB_TYPE_INTRA;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2736 s->mb_intra = 1;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2737
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2738 if(cbpc & 4) {
698
e050a053e259 h263_dc_scale() cleanup
michaelni
parents: 697
diff changeset
2739 change_qscale(s, quant_tab[get_bits(&s->gb, 2)]);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2740 }
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
2741 s->current_picture.qscale_table[xy]= s->qscale;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2742
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2743 s->mbintra_table[xy]= 1;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2744 for(i=0; i<6; i++){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2745 int dc_pred_dir;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2746 int dc= mpeg4_decode_dc(s, i, &dc_pred_dir);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2747 if(dc < 0){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2748 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
2749 return -1;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2750 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2751 dir<<=1;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2752 if(dc_pred_dir) dir|=1;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2753 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2754 s->pred_dir_table[xy]= dir;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2755 }else{ /* P/S_TYPE */
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2756 int mx, my, pred_x, pred_y, bits;
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
2757 int16_t * const mot_val= s->motion_val[s->block_index[0]];
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2758 const int stride= s->block_wrap[0]*2;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2759
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2760 bits= show_bits(&s->gb, 17);
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2761 if(bits==MOTION_MARKER){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2762 return mb_num-1;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2763 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2764 skip_bits1(&s->gb);
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2765 if(bits&0x10000){
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2766 /* skip mb */
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2767 s->mb_type[xy]= MB_TYPE_SKIPED;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2768 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2769 PRINT_MB_TYPE("G");
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2770 mx= get_amv(s, 0);
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2771 my= get_amv(s, 1);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2772 }else{
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2773 PRINT_MB_TYPE("S");
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2774 mx=my=0;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2775 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2776 mot_val[0 ]= mot_val[2 ]=
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2777 mot_val[0+stride]= mot_val[2+stride]= mx;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2778 mot_val[1 ]= mot_val[3 ]=
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2779 mot_val[1+stride]= mot_val[3+stride]= my;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2780
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2781 if(s->mbintra_table[xy])
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2782 ff_clean_intra_table_entries(s);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2783 continue;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2784 }
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
2785 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
2786 if (cbpc < 0){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2787 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
2788 return -1;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2789 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2790 if (cbpc > 20)
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2791 cbpc+=3;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2792 else if (cbpc == 20)
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2793 fprintf(stderr, "Stuffing !");
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2794 s->cbp_table[xy]= cbpc&(8+3); //8 is dquant
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2795
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2796 s->mb_intra = ((cbpc & 4) != 0);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2797
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2798 if(s->mb_intra){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2799 PRINT_MB_TYPE("I");
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2800 s->mbintra_table[xy]= 1;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2801 s->mb_type[xy]= MB_TYPE_INTRA;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2802 mot_val[0 ]= mot_val[2 ]=
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2803 mot_val[0+stride]= mot_val[2+stride]= 0;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2804 mot_val[1 ]= mot_val[3 ]=
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2805 mot_val[1+stride]= mot_val[3+stride]= 0;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2806 }else{
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2807 if(s->mbintra_table[xy])
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2808 ff_clean_intra_table_entries(s);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2809
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2810 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
2811 s->mcsel= get_bits1(&s->gb);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2812 else s->mcsel= 0;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2813
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2814 if ((cbpc & 16) == 0) {
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2815 PRINT_MB_TYPE("P");
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2816 /* 16x16 motion prediction */
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2817 s->mb_type[xy]= MB_TYPE_INTER;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2818
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2819 h263_pred_motion(s, 0, &pred_x, &pred_y);
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2820 if(!s->mcsel){
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2821 mx = h263_decode_motion(s, pred_x, s->f_code);
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2822 if (mx >= 0xffff)
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2823 return -1;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2824
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2825 my = h263_decode_motion(s, pred_y, s->f_code);
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2826 if (my >= 0xffff)
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2827 return -1;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2828 } else {
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2829 mx = get_amv(s, 0);
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2830 my = get_amv(s, 1);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2831 }
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
2832
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2833 mot_val[0 ]= mot_val[2 ] =
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2834 mot_val[0+stride]= mot_val[2+stride]= mx;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2835 mot_val[1 ]= mot_val[3 ]=
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2836 mot_val[1+stride]= mot_val[3+stride]= my;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2837 } else {
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2838 int i;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2839 PRINT_MB_TYPE("4");
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2840 s->mb_type[xy]= MB_TYPE_INTER4V;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2841 for(i=0;i<4;i++) {
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
2842 int16_t *mot_val= h263_pred_motion(s, i, &pred_x, &pred_y);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2843 mx = h263_decode_motion(s, pred_x, s->f_code);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2844 if (mx >= 0xffff)
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2845 return -1;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2846
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2847 my = h263_decode_motion(s, pred_y, s->f_code);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2848 if (my >= 0xffff)
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2849 return -1;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2850 mot_val[0] = mx;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2851 mot_val[1] = my;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2852 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2853 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2854 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2855 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2856 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2857 s->mb_x= 0;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2858 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2859
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2860 return mb_num;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2861 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2862
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2863 /**
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2864 * decode second partition.
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2865 * @return <0 if an error occured
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2866 */
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2867 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
2868 int mb_num=0;
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
2869 static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2870
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2871 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
2872 s->first_slice_line=1;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2873 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
2874 ff_init_block_index(s);
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2875 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
2876 const int xy= s->mb_x + s->mb_y*s->mb_width;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2877
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2878 mb_num++;
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2879 ff_update_block_index(s);
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2880 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
2881 s->first_slice_line=0;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2882
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2883 if(s->pict_type==I_TYPE){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2884 int ac_pred= get_bits1(&s->gb);
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
2885 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2886 if(cbpy<0){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2887 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
2888 return -1;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2889 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2890
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2891 s->cbp_table[xy]|= cbpy<<2;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2892 s->pred_dir_table[xy]|= ac_pred<<7;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2893 }else{ /* P || S_TYPE */
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2894 if(s->mb_type[xy]&MB_TYPE_INTRA){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2895 int dir=0,i;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2896 int ac_pred = get_bits1(&s->gb);
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
2897 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2898
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, "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
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 if(s->cbp_table[xy] & 8) {
698
e050a053e259 h263_dc_scale() cleanup
michaelni
parents: 697
diff changeset
2905 change_qscale(s, quant_tab[get_bits(&s->gb, 2)]);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2906 }
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
2907 s->current_picture.qscale_table[xy]= s->qscale;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2908
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2909 for(i=0; i<6; i++){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2910 int dc_pred_dir;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2911 int dc= mpeg4_decode_dc(s, i, &dc_pred_dir);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2912 if(dc < 0){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2913 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
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 dir<<=1;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2917 if(dc_pred_dir) dir|=1;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2918 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2919 s->cbp_table[xy]&= 3; //remove dquant
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2920 s->cbp_table[xy]|= cbpy<<2;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2921 s->pred_dir_table[xy]= dir | (ac_pred<<7);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2922 }else if(s->mb_type[xy]&MB_TYPE_SKIPED){
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
2923 s->current_picture.qscale_table[xy]= s->qscale;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2924 s->cbp_table[xy]= 0;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2925 }else{
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
2926 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2927
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2928 if(cbpy<0){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2929 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
2930 return -1;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2931 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2932
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2933 if(s->cbp_table[xy] & 8) {
698
e050a053e259 h263_dc_scale() cleanup
michaelni
parents: 697
diff changeset
2934 change_qscale(s, quant_tab[get_bits(&s->gb, 2)]);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2935 }
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
2936 s->current_picture.qscale_table[xy]= s->qscale;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2937
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2938 s->cbp_table[xy]&= 3; //remove dquant
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2939 s->cbp_table[xy]|= (cbpy^0xf)<<2;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2940 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2941 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2942 }
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2943 if(mb_num >= mb_count) return 0;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2944 s->mb_x= 0;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2945 }
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2946 return 0;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2947 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2948
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2949 /**
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2950 * decodes the first & second partition
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2951 * @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
2952 */
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2953 int ff_mpeg4_decode_partitions(MpegEncContext *s)
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2954 {
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2955 int mb_num;
1144
21c85c4ab2f0 error resilience cleanup (its faster too...)
michaelni
parents: 1137
diff changeset
2956 const int part_a_error= s->pict_type==I_TYPE ? (DC_ERROR|MV_ERROR) : MV_ERROR;
21c85c4ab2f0 error resilience cleanup (its faster too...)
michaelni
parents: 1137
diff changeset
2957 const int part_a_end = s->pict_type==I_TYPE ? (DC_END |MV_END) : MV_END;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2958
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2959 mb_num= mpeg4_decode_partition_a(s);
1144
21c85c4ab2f0 error resilience cleanup (its faster too...)
michaelni
parents: 1137
diff changeset
2960 if(mb_num<0){
21c85c4ab2f0 error resilience cleanup (its faster too...)
michaelni
parents: 1137
diff changeset
2961 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, part_a_error);
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2962 return -1;
1144
21c85c4ab2f0 error resilience cleanup (its faster too...)
michaelni
parents: 1137
diff changeset
2963 }
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2964
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2965 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
2966 fprintf(stderr, "slice below monitor ...\n");
1144
21c85c4ab2f0 error resilience cleanup (its faster too...)
michaelni
parents: 1137
diff changeset
2967 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, part_a_error);
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2968 return -1;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2969 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2970
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2971 s->mb_num_left= mb_num;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2972
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2973 if(s->pict_type==I_TYPE){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2974 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
2975 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
2976 return -1;
1144
21c85c4ab2f0 error resilience cleanup (its faster too...)
michaelni
parents: 1137
diff changeset
2977 }
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2978 }else{
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2979 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
2980 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
2981 return -1;
1144
21c85c4ab2f0 error resilience cleanup (its faster too...)
michaelni
parents: 1137
diff changeset
2982 }
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2983 }
1144
21c85c4ab2f0 error resilience cleanup (its faster too...)
michaelni
parents: 1137
diff changeset
2984 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, part_a_end);
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2985
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2986 if( mpeg4_decode_partition_b(s, mb_num) < 0){
1144
21c85c4ab2f0 error resilience cleanup (its faster too...)
michaelni
parents: 1137
diff changeset
2987 if(s->pict_type==P_TYPE)
21c85c4ab2f0 error resilience cleanup (its faster too...)
michaelni
parents: 1137
diff changeset
2988 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, DC_ERROR);
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2989 return -1;
1144
21c85c4ab2f0 error resilience cleanup (its faster too...)
michaelni
parents: 1137
diff changeset
2990 }else{
21c85c4ab2f0 error resilience cleanup (its faster too...)
michaelni
parents: 1137
diff changeset
2991 if(s->pict_type==P_TYPE)
21c85c4ab2f0 error resilience cleanup (its faster too...)
michaelni
parents: 1137
diff changeset
2992 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, DC_END);
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2993 }
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2994
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2995 return 0;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2996 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2997
745
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 * decode partition C of one MB.
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3000 * @return <0 if an error occured
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3001 */
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3002 static int mpeg4_decode_partitioned_mb(MpegEncContext *s, DCTELEM block[6][64])
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3003 {
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3004 int cbp, mb_type;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3005 const int xy= s->mb_x + s->mb_y*s->mb_width;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3006
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3007 mb_type= s->mb_type[xy];
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3008 cbp = s->cbp_table[xy];
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3009
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
3010 if(s->current_picture.qscale_table[xy] != s->qscale){
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
3011 s->qscale= s->current_picture.qscale_table[xy];
698
e050a053e259 h263_dc_scale() cleanup
michaelni
parents: 697
diff changeset
3012 s->y_dc_scale= s->y_dc_scale_table[ s->qscale ];
e050a053e259 h263_dc_scale() cleanup
michaelni
parents: 697
diff changeset
3013 s->c_dc_scale= s->c_dc_scale_table[ s->qscale ];
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3014 }
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3015
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3016 if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3017 int i;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3018 for(i=0; i<4; i++){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3019 s->mv[0][i][0] = s->motion_val[ s->block_index[i] ][0];
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3020 s->mv[0][i][1] = s->motion_val[ s->block_index[i] ][1];
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3021 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3022 s->mb_intra = mb_type&MB_TYPE_INTRA;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3023
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3024 if (mb_type&MB_TYPE_SKIPED) {
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3025 /* skip mb */
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3026 for(i=0;i<6;i++)
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3027 s->block_last_index[i] = -1;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3028 s->mv_dir = MV_DIR_FORWARD;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3029 s->mv_type = MV_TYPE_16X16;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3030 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3031 s->mcsel=1;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3032 s->mb_skiped = 0;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3033 }else{
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3034 s->mcsel=0;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3035 s->mb_skiped = 1;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3036 }
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3037 }else if(s->mb_intra){
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3038 s->ac_pred = s->pred_dir_table[xy]>>7;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3039 }else if(!s->mb_intra){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3040 // s->mcsel= 0; //FIXME do we need to init that
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3041
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3042 s->mv_dir = MV_DIR_FORWARD;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3043 if (mb_type&MB_TYPE_INTER4V) {
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3044 s->mv_type = MV_TYPE_8X8;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3045 } else {
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3046 s->mv_type = MV_TYPE_16X16;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3047 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3048 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3049 } else { /* I-Frame */
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3050 s->mb_intra = 1;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3051 s->ac_pred = s->pred_dir_table[xy]>>7;
1132
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
3052 }
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
3053
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
3054 if (!(mb_type&MB_TYPE_SKIPED)) {
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
3055 int i;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3056 /* decode each block */
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3057 for (i = 0; i < 6; i++) {
1132
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
3058 if(mpeg4_decode_block(s, block[i], i, cbp&32, s->mb_intra, s->rvlc) < 0){
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
3059 fprintf(stderr, "texture corrupted at %d %d %d\n", s->mb_x, s->mb_y, s->mb_intra);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3060 return -1;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3061 }
718
16dab8296293 fixing custom quantizer matrix decoding
michaelni
parents: 706
diff changeset
3062 cbp+=cbp;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3063 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3064 }
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
3065
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3066 /* per-MB end of slice check */
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3067
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3068 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
3069 //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
3070 if(mpeg4_is_resync(s))
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3071 return SLICE_END;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3072 else
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3073 return SLICE_NOEND;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3074 }else{
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3075 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
3076 return SLICE_END;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3077 else
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3078 return SLICE_OK;
619
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
3079 }
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
3080 }
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3081
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3082 int ff_h263_decode_mb(MpegEncContext *s,
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3083 DCTELEM block[6][64])
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3084 {
986e461dc072 Initial revision
glantau
parents:
diff changeset
3085 int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
3086 int16_t *mot_val;
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
3087 static int8_t quant_tab[4] = { -1, -2, 1, 2 };
264
28c5c62b1c4c support decoding (with mplayer) of 3 .mp4 files from mphq
michaelni
parents: 263
diff changeset
3088
523
c7e4c8b9a3c4 warning fix patch by atmos
michaelni
parents: 498
diff changeset
3089 if(s->mb_x==0) PRINT_MB_TYPE("\n");
359
df0736462b9f move ABS() to common.h
michaelni
parents: 358
diff changeset
3090
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3091 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
3092 if (get_bits1(&s->gb)) {
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3093 /* skip mb */
986e461dc072 Initial revision
glantau
parents:
diff changeset
3094 s->mb_intra = 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3095 for(i=0;i<6;i++)
986e461dc072 Initial revision
glantau
parents:
diff changeset
3096 s->block_last_index[i] = -1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3097 s->mv_dir = MV_DIR_FORWARD;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3098 s->mv_type = MV_TYPE_16X16;
255
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
3099 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
359
df0736462b9f move ABS() to common.h
michaelni
parents: 358
diff changeset
3100 PRINT_MB_TYPE("G");
255
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
3101 s->mcsel=1;
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3102 s->mv[0][0][0]= get_amv(s, 0);
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3103 s->mv[0][0][1]= get_amv(s, 1);
255
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
3104
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
3105 s->mb_skiped = 0;
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
3106 }else{
359
df0736462b9f move ABS() to common.h
michaelni
parents: 358
diff changeset
3107 PRINT_MB_TYPE("S");
255
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
3108 s->mcsel=0;
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
3109 s->mv[0][0][0] = 0;
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
3110 s->mv[0][0][1] = 0;
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
3111 s->mb_skiped = 1;
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
3112 }
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3113 goto end;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3114 }
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
3115 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
3116 //fprintf(stderr, "\tCBPC: %d", cbpc);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3117 if (cbpc < 0)
986e461dc072 Initial revision
glantau
parents:
diff changeset
3118 return -1;
161
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3119 if (cbpc > 20)
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3120 cbpc+=3;
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3121 else if (cbpc == 20)
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3122 fprintf(stderr, "Stuffing !");
144
cb5dabd00ba2 - Bug fix on inter MCBPC table for inter+q.
pulento
parents: 110
diff changeset
3123
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3124 dquant = cbpc & 8;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3125 s->mb_intra = ((cbpc & 4) != 0);
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3126 if (s->mb_intra) goto intra;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3127
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3128 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
3129 s->mcsel= get_bits1(&s->gb);
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
3130 else s->mcsel= 0;
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
3131 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3132 cbp = (cbpc & 3) | ((cbpy ^ 0xf) << 2);
986e461dc072 Initial revision
glantau
parents:
diff changeset
3133 if (dquant) {
698
e050a053e259 h263_dc_scale() cleanup
michaelni
parents: 697
diff changeset
3134 change_qscale(s, quant_tab[get_bits(&s->gb, 2)]);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3135 }
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3136 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
3137 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
3138
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3139 s->mv_dir = MV_DIR_FORWARD;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3140 if ((cbpc & 16) == 0) {
619
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
3141 if(s->mcsel){
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
3142 PRINT_MB_TYPE("G");
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
3143 /* 16x16 global motion prediction */
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
3144 s->mv_type = MV_TYPE_16X16;
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3145 mx= get_amv(s, 0);
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3146 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
3147 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
3148 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
3149 }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
3150 PRINT_MB_TYPE("f");
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
3151 /* 16x8 field motion prediction */
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
3152 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
3153
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
3154 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
3155 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
3156
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
3157 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
3158
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
3159 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
3160 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
3161 if (mx >= 0xffff)
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
3162 return -1;
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
3163
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
3164 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
3165 if (my >= 0xffff)
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
3166 return -1;
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
3167
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
3168 s->mv[0][i][0] = mx;
661
a0901e38c564 fixing interlaced mpeg4 decoding
michaelni
parents: 660
diff changeset
3169 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
3170 }
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
3171 }else{
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
3172 PRINT_MB_TYPE("P");
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
3173 /* 16x16 motion prediction */
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
3174 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
3175 h263_pred_motion(s, 0, &pred_x, &pred_y);
1089
7e79a58954b1 h263(+) clenaup & bugfixes
michaelni
parents: 1070
diff changeset
3176 if (s->umvplus)
619
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
3177 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
3178 else
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
3179 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
3180
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
3181 if (mx >= 0xffff)
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
3182 return -1;
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
3183
1089
7e79a58954b1 h263(+) clenaup & bugfixes
michaelni
parents: 1070
diff changeset
3184 if (s->umvplus)
619
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
3185 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
3186 else
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
3187 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
3188
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
3189 if (my >= 0xffff)
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
3190 return -1;
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
3191 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
3192 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
3193
1089
7e79a58954b1 h263(+) clenaup & bugfixes
michaelni
parents: 1070
diff changeset
3194 if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
619
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
3195 skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
255
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
3196 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3197 } else {
359
df0736462b9f move ABS() to common.h
michaelni
parents: 358
diff changeset
3198 PRINT_MB_TYPE("4");
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3199 s->mv_type = MV_TYPE_8X8;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3200 for(i=0;i<4;i++) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
3201 mot_val = h263_pred_motion(s, i, &pred_x, &pred_y);
1089
7e79a58954b1 h263(+) clenaup & bugfixes
michaelni
parents: 1070
diff changeset
3202 if (s->umvplus)
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3203 mx = h263p_decode_umotion(s, pred_x);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3204 else
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3205 mx = h263_decode_motion(s, pred_x, s->f_code);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3206 if (mx >= 0xffff)
986e461dc072 Initial revision
glantau
parents:
diff changeset
3207 return -1;
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3208
1089
7e79a58954b1 h263(+) clenaup & bugfixes
michaelni
parents: 1070
diff changeset
3209 if (s->umvplus)
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3210 my = h263p_decode_umotion(s, pred_y);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3211 else
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3212 my = h263_decode_motion(s, pred_y, s->f_code);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3213 if (my >= 0xffff)
986e461dc072 Initial revision
glantau
parents:
diff changeset
3214 return -1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3215 s->mv[0][i][0] = mx;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3216 s->mv[0][i][1] = my;
1089
7e79a58954b1 h263(+) clenaup & bugfixes
michaelni
parents: 1070
diff changeset
3217 if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3218 skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3219 mot_val[0] = mx;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3220 mot_val[1] = my;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3221 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
3222 }
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3223 } else if(s->pict_type==B_TYPE) {
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3224 int modb1; // first bit of modb
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3225 int modb2; // second bit of modb
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3226 int mb_type;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3227
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3228 s->mb_intra = 0; //B-frames never contain intra blocks
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3229 s->mcsel=0; // ... true gmc blocks
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3230
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3231 if(s->mb_x==0){
674
4490bfbb932d interlaced b frames fix
michaelni
parents: 669
diff changeset
3232 for(i=0; i<2; i++){
4490bfbb932d interlaced b frames fix
michaelni
parents: 669
diff changeset
3233 s->last_mv[i][0][0]=
4490bfbb932d interlaced b frames fix
michaelni
parents: 669
diff changeset
3234 s->last_mv[i][0][1]=
4490bfbb932d interlaced b frames fix
michaelni
parents: 669
diff changeset
3235 s->last_mv[i][1][0]=
4490bfbb932d interlaced b frames fix
michaelni
parents: 669
diff changeset
3236 s->last_mv[i][1][1]= 0;
4490bfbb932d interlaced b frames fix
michaelni
parents: 669
diff changeset
3237 }
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3238 }
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3239
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3240 /* if we skipped it in the future P Frame than skip it now too */
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
3241 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
3242
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3243 if(s->mb_skiped){
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3244 /* skip mb */
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3245 for(i=0;i<6;i++)
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3246 s->block_last_index[i] = -1;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3247
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3248 s->mv_dir = MV_DIR_FORWARD;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3249 s->mv_type = MV_TYPE_16X16;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3250 s->mv[0][0][0] = 0;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3251 s->mv[0][0][1] = 0;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3252 s->mv[1][0][0] = 0;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3253 s->mv[1][0][1] = 0;
523
c7e4c8b9a3c4 warning fix patch by atmos
michaelni
parents: 498
diff changeset
3254 PRINT_MB_TYPE("s");
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3255 goto end;
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3256 }
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3257
666
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3258 modb1= get_bits1(&s->gb);
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3259 if(modb1){
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3260 mb_type=4; //like MB_TYPE_B_DIRECT but no vectors coded
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3261 cbp=0;
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3262 }else{
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3263 int field_mv;
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3264
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3265 modb2= get_bits1(&s->gb);
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
3266 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
3267 if(modb2) cbp= 0;
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3268 else cbp= get_bits(&s->gb, 6);
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3269
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3270 if (mb_type!=MB_TYPE_B_DIRECT && cbp) {
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3271 if(get_bits1(&s->gb)){
698
e050a053e259 h263_dc_scale() cleanup
michaelni
parents: 697
diff changeset
3272 change_qscale(s, get_bits1(&s->gb)*4 - 2);
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3273 }
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3274 }
666
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3275 field_mv=0;
664
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
3276
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
3277 if(!s->progressive_sequence){
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
3278 if(cbp)
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
3279 s->interlaced_dct= get_bits1(&s->gb);
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
3280
667
5446a41a00fe 10l (field select readed at the wrong place ...)
michaelni
parents: 666
diff changeset
3281 if(mb_type!=MB_TYPE_B_DIRECT && get_bits1(&s->gb)){
666
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3282 field_mv=1;
667
5446a41a00fe 10l (field select readed at the wrong place ...)
michaelni
parents: 666
diff changeset
3283
5446a41a00fe 10l (field select readed at the wrong place ...)
michaelni
parents: 666
diff changeset
3284 if(mb_type!=MB_TYPE_B_BACKW){
5446a41a00fe 10l (field select readed at the wrong place ...)
michaelni
parents: 666
diff changeset
3285 s->field_select[0][0]= get_bits1(&s->gb);
5446a41a00fe 10l (field select readed at the wrong place ...)
michaelni
parents: 666
diff changeset
3286 s->field_select[0][1]= get_bits1(&s->gb);
5446a41a00fe 10l (field select readed at the wrong place ...)
michaelni
parents: 666
diff changeset
3287 }
5446a41a00fe 10l (field select readed at the wrong place ...)
michaelni
parents: 666
diff changeset
3288 if(mb_type!=MB_TYPE_B_FORW){
5446a41a00fe 10l (field select readed at the wrong place ...)
michaelni
parents: 666
diff changeset
3289 s->field_select[1][0]= get_bits1(&s->gb);
5446a41a00fe 10l (field select readed at the wrong place ...)
michaelni
parents: 666
diff changeset
3290 s->field_select[1][1]= get_bits1(&s->gb);
5446a41a00fe 10l (field select readed at the wrong place ...)
michaelni
parents: 666
diff changeset
3291 }
5446a41a00fe 10l (field select readed at the wrong place ...)
michaelni
parents: 666
diff changeset
3292 }
666
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3293 }
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3294
667
5446a41a00fe 10l (field select readed at the wrong place ...)
michaelni
parents: 666
diff changeset
3295 s->mv_dir = 0;
666
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3296 if(mb_type!=MB_TYPE_B_DIRECT && !field_mv){
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3297 s->mv_type= MV_TYPE_16X16;
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3298 if(mb_type!=MB_TYPE_B_BACKW){
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3299 s->mv_dir = MV_DIR_FORWARD;
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3300
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3301 mx = h263_decode_motion(s, s->last_mv[0][0][0], s->f_code);
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3302 my = h263_decode_motion(s, s->last_mv[0][0][1], s->f_code);
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3303 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
3304 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
3305 }
666
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3306
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3307 if(mb_type!=MB_TYPE_B_FORW){
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3308 s->mv_dir |= MV_DIR_BACKWARD;
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3309
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3310 mx = h263_decode_motion(s, s->last_mv[1][0][0], s->b_code);
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3311 my = h263_decode_motion(s, s->last_mv[1][0][1], s->b_code);
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3312 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
3313 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
3314 }
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3315 if(mb_type!=MB_TYPE_B_DIRECT)
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3316 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
3317 }else if(mb_type!=MB_TYPE_B_DIRECT){
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3318 s->mv_type= MV_TYPE_FIELD;
667
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 if(mb_type!=MB_TYPE_B_BACKW){
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3321 s->mv_dir = MV_DIR_FORWARD;
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3322
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3323 for(i=0; i<2; i++){
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3324 mx = h263_decode_motion(s, s->last_mv[0][i][0] , s->f_code);
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3325 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
3326 s->last_mv[0][i][0]= s->mv[0][i][0] = mx;
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3327 s->last_mv[0][i][1]= (s->mv[0][i][1] = my)*2;
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3328 }
667
5446a41a00fe 10l (field select readed at the wrong place ...)
michaelni
parents: 666
diff changeset
3329 }
666
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3330
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3331 if(mb_type!=MB_TYPE_B_FORW){
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3332 s->mv_dir |= MV_DIR_BACKWARD;
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3333
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3334 for(i=0; i<2; i++){
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3335 mx = h263_decode_motion(s, s->last_mv[1][i][0] , s->b_code);
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3336 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
3337 s->last_mv[1][i][0]= s->mv[1][i][0] = mx;
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3338 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
3339 }
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
3340 }
666
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3341 if(mb_type!=MB_TYPE_B_DIRECT)
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3342 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
3343 }
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
3344 }
666
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3345
664
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
3346 if(mb_type==4 || mb_type==MB_TYPE_B_DIRECT){
666
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3347 if(mb_type==4)
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3348 mx=my=0;
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3349 else{
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3350 mx = h263_decode_motion(s, 0, 1);
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3351 my = h263_decode_motion(s, 0, 1);
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
3352 }
664
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
3353
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3354 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
936
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
3355 ff_mpeg4_set_direct_mv(s, mx, my);
664
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
3356 }
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
3357
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
3358 if(mb_type<0 || mb_type>4){
364
6b6332e7008a segfault fix for b-frame encoding with height%16!=0
michaelni
parents: 360
diff changeset
3359 printf("illegal MB_type\n");
6b6332e7008a segfault fix for b-frame encoding with height%16!=0
michaelni
parents: 360
diff changeset
3360 return -1;
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3361 }
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3362 } else { /* I-Frame */
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
3363 cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 1);
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3364 if (cbpc < 0)
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3365 return -1;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3366 dquant = cbpc & 4;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3367 s->mb_intra = 1;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3368 intra:
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3369 s->ac_pred = 0;
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
3370 if (s->h263_pred || s->h263_aic) {
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
3371 s->ac_pred = get_bits1(&s->gb);
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
3372 if (s->ac_pred && s->h263_aic)
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
3373 s->h263_aic_dir = get_bits1(&s->gb);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3374 }
591
d3f374218030 fixing mpeg4 mpeg quantizers
michaelni
parents: 582
diff changeset
3375 PRINT_MB_TYPE(s->ac_pred ? "A" : "I");
d3f374218030 fixing mpeg4 mpeg quantizers
michaelni
parents: 582
diff changeset
3376
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
3377 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3378 if(cbpy<0) return -1;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3379 cbp = (cbpc & 3) | (cbpy << 2);
986e461dc072 Initial revision
glantau
parents:
diff changeset
3380 if (dquant) {
698
e050a053e259 h263_dc_scale() cleanup
michaelni
parents: 697
diff changeset
3381 change_qscale(s, quant_tab[get_bits(&s->gb, 2)]);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3382 }
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3383
619
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
3384 if(!s->progressive_sequence)
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
3385 s->interlaced_dct= get_bits1(&s->gb);
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
3386
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
3387 /* decode each block */
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
3388 if (s->h263_pred) {
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
3389 for (i = 0; i < 6; i++) {
1132
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
3390 if (mpeg4_decode_block(s, block[i], i, cbp&32, 1, 0) < 0)
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
3391 return -1;
718
16dab8296293 fixing custom quantizer matrix decoding
michaelni
parents: 706
diff changeset
3392 cbp+=cbp;
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
3393 }
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
3394 } else {
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
3395 for (i = 0; i < 6; i++) {
718
16dab8296293 fixing custom quantizer matrix decoding
michaelni
parents: 706
diff changeset
3396 if (h263_decode_block(s, block[i], i, cbp&32) < 0)
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
3397 return -1;
718
16dab8296293 fixing custom quantizer matrix decoding
michaelni
parents: 706
diff changeset
3398 cbp+=cbp;
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
3399 }
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
3400 }
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3401 goto end;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3402 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
3403
986e461dc072 Initial revision
glantau
parents:
diff changeset
3404 /* decode each block */
986e461dc072 Initial revision
glantau
parents:
diff changeset
3405 if (s->h263_pred) {
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
3406 for (i = 0; i < 6; i++) {
1132
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
3407 if (mpeg4_decode_block(s, block[i], i, cbp&32, 0, 0) < 0)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3408 return -1;
718
16dab8296293 fixing custom quantizer matrix decoding
michaelni
parents: 706
diff changeset
3409 cbp+=cbp;
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
3410 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3411 } else {
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
3412 for (i = 0; i < 6; i++) {
718
16dab8296293 fixing custom quantizer matrix decoding
michaelni
parents: 706
diff changeset
3413 if (h263_decode_block(s, block[i], i, cbp&32) < 0)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3414 return -1;
718
16dab8296293 fixing custom quantizer matrix decoding
michaelni
parents: 706
diff changeset
3415 cbp+=cbp;
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
3416 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3417 }
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3418 end:
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3419
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3420 /* per-MB end of slice check */
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3421 if(s->codec_id==CODEC_ID_MPEG4){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3422 if(mpeg4_is_resync(s)){
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
3423 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
3424 return SLICE_OK;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3425 return SLICE_END;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3426 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3427 }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
3428 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
3429
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
3430 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
3431 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
3432 }
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
3433
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
3434 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
3435 return SLICE_END;
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3436 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3437
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3438 return SLICE_OK;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3439 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
3440
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3441 static int h263_decode_motion(MpegEncContext * s, int pred, int f_code)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3442 {
656
e47fa3e3f2d5 statistics for forw & back p-MBs instead of just one counter for both
michaelni
parents: 654
diff changeset
3443 int code, val, sign, shift, l;
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
3444 code = get_vlc2(&s->gb, mv_vlc.table, MV_VLC_BITS, 2);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3445 if (code < 0)
986e461dc072 Initial revision
glantau
parents:
diff changeset
3446 return 0xffff;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3447
986e461dc072 Initial revision
glantau
parents:
diff changeset
3448 if (code == 0)
986e461dc072 Initial revision
glantau
parents:
diff changeset
3449 return pred;
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
3450
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
3451 sign = get_bits1(&s->gb);
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3452 shift = f_code - 1;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3453 val = (code - 1) << shift;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3454 if (shift > 0)
986e461dc072 Initial revision
glantau
parents:
diff changeset
3455 val |= get_bits(&s->gb, shift);
986e461dc072 Initial revision
glantau
parents:
diff changeset
3456 val++;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3457 if (sign)
986e461dc072 Initial revision
glantau
parents:
diff changeset
3458 val = -val;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3459 val += pred;
475
6ccc48e4c41b run1 can be <0 bugfix (found by fabrice)
michaelni
parents: 469
diff changeset
3460
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3461 /* modulo decoding */
986e461dc072 Initial revision
glantau
parents:
diff changeset
3462 if (!s->h263_long_vectors) {
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
3463 l = 1 << (f_code + 4);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3464 if (val < -l) {
656
e47fa3e3f2d5 statistics for forw & back p-MBs instead of just one counter for both
michaelni
parents: 654
diff changeset
3465 val += l<<1;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3466 } else if (val >= l) {
656
e47fa3e3f2d5 statistics for forw & back p-MBs instead of just one counter for both
michaelni
parents: 654
diff changeset
3467 val -= l<<1;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3468 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
3469 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
3470 /* horrible h263 long vector mode */
986e461dc072 Initial revision
glantau
parents:
diff changeset
3471 if (pred < -31 && val < -63)
986e461dc072 Initial revision
glantau
parents:
diff changeset
3472 val += 64;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3473 if (pred > 32 && val > 63)
986e461dc072 Initial revision
glantau
parents:
diff changeset
3474 val -= 64;
154
f914f710b8d0 - Fixed a bug on H.263 MV prediction for MB on GOBs limits.
pulento
parents: 144
diff changeset
3475
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3476 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
3477 return val;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3478 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
3479
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3480 /* Decodes RVLC of H.263+ UMV */
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3481 static int h263p_decode_umotion(MpegEncContext * s, int pred)
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3482 {
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3483 int code = 0, sign;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3484
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3485 if (get_bits1(&s->gb)) /* Motion difference = 0 */
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3486 return pred;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3487
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3488 code = 2 + get_bits1(&s->gb);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3489
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3490 while (get_bits1(&s->gb))
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3491 {
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3492 code <<= 1;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3493 code += get_bits1(&s->gb);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3494 }
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3495 sign = code & 1;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3496 code >>= 1;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3497
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3498 code = (sign) ? (pred - code) : (pred + code);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3499 #ifdef DEBUG
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3500 fprintf(stderr,"H.263+ UMV Motion = %d\n", code);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3501 #endif
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3502 return code;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3503
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3504 }
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
3505
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3506 static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
986e461dc072 Initial revision
glantau
parents:
diff changeset
3507 int n, int coded)
986e461dc072 Initial revision
glantau
parents:
diff changeset
3508 {
986e461dc072 Initial revision
glantau
parents:
diff changeset
3509 int code, level, i, j, last, run;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3510 RLTable *rl = &rl_inter;
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
3511 const uint8_t *scan_table;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3512
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
3513 scan_table = s->intra_scantable.permutated;
249
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
3514 if (s->h263_aic && s->mb_intra) {
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
3515 rl = &rl_intra_aic;
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
3516 i = 0;
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
3517 if (s->ac_pred) {
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
3518 if (s->h263_aic_dir)
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
3519 scan_table = s->intra_v_scantable.permutated; /* left */
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
3520 else
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
3521 scan_table = s->intra_h_scantable.permutated; /* top */
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
3522 }
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
3523 } else if (s->mb_intra) {
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
3524 /* DC coef */
1090
michaelni
parents: 1089
diff changeset
3525 if(s->h263_rv10){
michaelni
parents: 1089
diff changeset
3526 if (s->rv10_version == 3 && s->pict_type == I_TYPE) {
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3527 int component, diff;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3528 component = (n <= 3 ? 0 : n - 4 + 1);
986e461dc072 Initial revision
glantau
parents:
diff changeset
3529 level = s->last_dc[component];
986e461dc072 Initial revision
glantau
parents:
diff changeset
3530 if (s->rv10_first_dc_coded[component]) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
3531 diff = rv_decode_dc(s, n);
986e461dc072 Initial revision
glantau
parents:
diff changeset
3532 if (diff == 0xffff)
986e461dc072 Initial revision
glantau
parents:
diff changeset
3533 return -1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3534 level += diff;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3535 level = level & 0xff; /* handle wrap round */
986e461dc072 Initial revision
glantau
parents:
diff changeset
3536 s->last_dc[component] = level;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3537 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
3538 s->rv10_first_dc_coded[component] = 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3539 }
1090
michaelni
parents: 1089
diff changeset
3540 } else {
michaelni
parents: 1089
diff changeset
3541 level = get_bits(&s->gb, 8);
michaelni
parents: 1089
diff changeset
3542 }
michaelni
parents: 1089
diff changeset
3543 }else{
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3544 level = get_bits(&s->gb, 8);
1089
7e79a58954b1 h263(+) clenaup & bugfixes
michaelni
parents: 1070
diff changeset
3545 if((level&0x7F) == 0){
1090
michaelni
parents: 1089
diff changeset
3546 fprintf(stderr, "illegal dc %d at %d %d\n", level, s->mb_x, s->mb_y);
1089
7e79a58954b1 h263(+) clenaup & bugfixes
michaelni
parents: 1070
diff changeset
3547 return -1;
7e79a58954b1 h263(+) clenaup & bugfixes
michaelni
parents: 1070
diff changeset
3548 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3549 if (level == 255)
986e461dc072 Initial revision
glantau
parents:
diff changeset
3550 level = 128;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3551 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
3552 block[0] = level;
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
3553 i = 1;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3554 } else {
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
3555 i = 0;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3556 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
3557 if (!coded) {
249
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
3558 if (s->mb_intra && s->h263_aic)
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
3559 goto not_coded;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3560 s->block_last_index[n] = i - 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3561 return 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3562 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
3563
986e461dc072 Initial revision
glantau
parents:
diff changeset
3564 for(;;) {
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
3565 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
3566 if (code < 0){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3567 fprintf(stderr, "illegal ac vlc code at %dx%d\n", s->mb_x, s->mb_y);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3568 return -1;
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3569 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3570 if (code == rl->n) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
3571 /* escape */
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
3572 last = get_bits1(&s->gb);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3573 run = get_bits(&s->gb, 6);
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
3574 level = (int8_t)get_bits(&s->gb, 8);
1089
7e79a58954b1 h263(+) clenaup & bugfixes
michaelni
parents: 1070
diff changeset
3575 if(level == -128){
7e79a58954b1 h263(+) clenaup & bugfixes
michaelni
parents: 1070
diff changeset
3576 if (s->h263_rv10) {
7e79a58954b1 h263(+) clenaup & bugfixes
michaelni
parents: 1070
diff changeset
3577 /* XXX: should patch encoder too */
7e79a58954b1 h263(+) clenaup & bugfixes
michaelni
parents: 1070
diff changeset
3578 level = get_bits(&s->gb, 12);
7e79a58954b1 h263(+) clenaup & bugfixes
michaelni
parents: 1070
diff changeset
3579 level= (level + ((-1)<<11)) ^ ((-1)<<11); //sign extension
7e79a58954b1 h263(+) clenaup & bugfixes
michaelni
parents: 1070
diff changeset
3580 }else{
7e79a58954b1 h263(+) clenaup & bugfixes
michaelni
parents: 1070
diff changeset
3581 level = get_bits(&s->gb, 5);
7e79a58954b1 h263(+) clenaup & bugfixes
michaelni
parents: 1070
diff changeset
3582 level += get_bits(&s->gb, 6)<<5;
7e79a58954b1 h263(+) clenaup & bugfixes
michaelni
parents: 1070
diff changeset
3583 level= (level + ((-1)<<10)) ^ ((-1)<<10); //sign extension
7e79a58954b1 h263(+) clenaup & bugfixes
michaelni
parents: 1070
diff changeset
3584 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3585 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
3586 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
3587 run = rl->table_run[code];
986e461dc072 Initial revision
glantau
parents:
diff changeset
3588 level = rl->table_level[code];
986e461dc072 Initial revision
glantau
parents:
diff changeset
3589 last = code >= rl->last;
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
3590 if (get_bits1(&s->gb))
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3591 level = -level;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3592 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
3593 i += run;
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3594 if (i >= 64){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3595 fprintf(stderr, "run overflow at %dx%d\n", s->mb_x, s->mb_y);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3596 return -1;
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3597 }
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
3598 j = scan_table[i];
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3599 block[j] = level;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3600 if (last)
986e461dc072 Initial revision
glantau
parents:
diff changeset
3601 break;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3602 i++;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3603 }
249
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
3604 not_coded:
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
3605 if (s->mb_intra && s->h263_aic) {
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
3606 h263_pred_acdc(s, block, n);
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
3607 i = 63;
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
3608 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3609 s->block_last_index[n] = i;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3610 return 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3611 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
3612
1034
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
3613 /**
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
3614 * decodes the dc value.
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
3615 * @param n block index (0-3 are luma, 4-5 are chroma)
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
3616 * @param dir_ptr the prediction direction will be stored here
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
3617 * @return the quantized dc
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
3618 */
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3619 static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3620 {
986e461dc072 Initial revision
glantau
parents:
diff changeset
3621 int level, pred, code;
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
3622 uint16_t *dc_val;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3623
986e461dc072 Initial revision
glantau
parents:
diff changeset
3624 if (n < 4)
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
3625 code = get_vlc2(&s->gb, dc_lum.table, DC_VLC_BITS, 1);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3626 else
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
3627 code = get_vlc2(&s->gb, dc_chrom.table, DC_VLC_BITS, 1);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3628 if (code < 0 || code > 9 /* && s->nbit<9 */){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3629 fprintf(stderr, "illegal dc vlc\n");
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3630 return -1;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3631 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3632 if (code == 0) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
3633 level = 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3634 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
3635 level = get_bits(&s->gb, code);
986e461dc072 Initial revision
glantau
parents:
diff changeset
3636 if ((level >> (code - 1)) == 0) /* if MSB not set it is negative*/
986e461dc072 Initial revision
glantau
parents:
diff changeset
3637 level = - (level ^ ((1 << code) - 1));
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3638 if (code > 8){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3639 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
3640 if(s->error_resilience>=2){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3641 fprintf(stderr, "dc marker bit missing\n");
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3642 return -1;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3643 }
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3644 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3645 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3646 }
498
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
3647 pred = ff_mpeg4_pred_dc(s, n, &dc_val, dir_ptr);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3648 level += pred;
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3649 if (level < 0){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3650 if(s->error_resilience>=3){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3651 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
3652 return -1;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3653 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3654 level = 0;
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3655 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3656 if (n < 4) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
3657 *dc_val = level * s->y_dc_scale;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3658 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
3659 *dc_val = level * s->c_dc_scale;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3660 }
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3661 if(s->error_resilience>=3){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3662 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
3663 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
3664 return -1;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3665 }
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 return level;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3668 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
3669
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3670 /**
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3671 * decodes a block.
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3672 * @return <0 if an error occured
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3673 */
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3674 static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
1132
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
3675 int n, int coded, int intra, int rvlc)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3676 {
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3677 int level, i, last, run;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3678 int dc_pred_dir;
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
3679 RLTable * rl;
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
3680 RL_VLC_ELEM * rl_vlc;
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
3681 const uint8_t * scan_table;
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3682 int qmul, qadd;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3683
1132
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
3684 //Note intra & rvlc should be optimized away if this is inlined
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
3685
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
3686 if(intra) {
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3687 /* DC coef */
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3688 if(s->partitioned_frame){
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3689 level = s->dc_val[0][ s->block_index[n] ];
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3690 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
3691 else level= (level + (s->c_dc_scale>>1))/s->c_dc_scale;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3692 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
3693 }else{
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3694 level = mpeg4_decode_dc(s, n, &dc_pred_dir);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3695 if (level < 0)
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3696 return -1;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3697 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3698 block[0] = level;
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3699 i = 0;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3700 if (!coded)
986e461dc072 Initial revision
glantau
parents:
diff changeset
3701 goto not_coded;
1132
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
3702
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
3703 if(rvlc){
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
3704 rl = &rvlc_rl_intra;
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
3705 rl_vlc = rvlc_rl_intra.rl_vlc[0];
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
3706 }else{
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
3707 rl = &rl_intra;
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
3708 rl_vlc = rl_intra.rl_vlc[0];
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
3709 }
718
16dab8296293 fixing custom quantizer matrix decoding
michaelni
parents: 706
diff changeset
3710 if (s->ac_pred) {
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3711 if (dc_pred_dir == 0)
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
3712 scan_table = s->intra_v_scantable.permutated; /* left */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3713 else
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
3714 scan_table = s->intra_h_scantable.permutated; /* top */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3715 } else {
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
3716 scan_table = s->intra_scantable.permutated;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3717 }
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3718 qmul=1;
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3719 qadd=0;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3720 } else {
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3721 i = -1;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3722 if (!coded) {
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3723 s->block_last_index[n] = i;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3724 return 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3725 }
1132
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
3726 if(rvlc) rl = &rvlc_rl_inter;
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
3727 else rl = &rl_inter;
661
a0901e38c564 fixing interlaced mpeg4 decoding
michaelni
parents: 660
diff changeset
3728
718
16dab8296293 fixing custom quantizer matrix decoding
michaelni
parents: 706
diff changeset
3729 scan_table = s->intra_scantable.permutated;
661
a0901e38c564 fixing interlaced mpeg4 decoding
michaelni
parents: 660
diff changeset
3730
591
d3f374218030 fixing mpeg4 mpeg quantizers
michaelni
parents: 582
diff changeset
3731 if(s->mpeg_quant){
d3f374218030 fixing mpeg4 mpeg quantizers
michaelni
parents: 582
diff changeset
3732 qmul=1;
d3f374218030 fixing mpeg4 mpeg quantizers
michaelni
parents: 582
diff changeset
3733 qadd=0;
1132
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
3734 if(rvlc){
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
3735 rl_vlc = rvlc_rl_inter.rl_vlc[0];
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
3736 }else{
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
3737 rl_vlc = rl_inter.rl_vlc[0];
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
3738 }
591
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;
1132
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
3742 if(rvlc){
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
3743 rl_vlc = rvlc_rl_inter.rl_vlc[s->qscale];
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
3744 }else{
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
3745 rl_vlc = rl_inter.rl_vlc[s->qscale];
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
3746 }
591
d3f374218030 fixing mpeg4 mpeg quantizers
michaelni
parents: 582
diff changeset
3747 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3748 }
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3749 {
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3750 OPEN_READER(re, &s->gb);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3751 for(;;) {
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3752 UPDATE_CACHE(re, &s->gb);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3753 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3754 if (level==0) {
1132
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
3755 /* escape */
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
3756 if(rvlc){
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
3757 if(SHOW_UBITS(re, &s->gb, 1)==0){
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
3758 fprintf(stderr, "1. marker bit missing in rvlc esc\n");
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
3759 return -1;
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
3760 }; SKIP_CACHE(re, &s->gb, 1);
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
3761
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
3762 last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
3763 run= SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6);
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
3764 SKIP_COUNTER(re, &s->gb, 1+1+6);
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
3765 UPDATE_CACHE(re, &s->gb);
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
3766
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
3767 if(SHOW_UBITS(re, &s->gb, 1)==0){
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
3768 fprintf(stderr, "2. marker bit missing in rvlc esc\n");
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
3769 return -1;
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
3770 }; SKIP_CACHE(re, &s->gb, 1);
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
3771
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
3772 level= SHOW_UBITS(re, &s->gb, 11); SKIP_CACHE(re, &s->gb, 11);
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
3773
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
3774 if(SHOW_UBITS(re, &s->gb, 5)!=0x10){
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
3775 fprintf(stderr, "reverse esc missing\n");
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
3776 return -1;
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
3777 }; SKIP_CACHE(re, &s->gb, 5);
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
3778
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
3779 level= level * qmul + qadd;
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
3780 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); LAST_SKIP_CACHE(re, &s->gb, 1);
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
3781 SKIP_COUNTER(re, &s->gb, 1+11+5+1);
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
3782
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
3783 i+= run + 1;
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
3784 if(last) i+=192;
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
3785 }else{
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3786 int cache;
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3787 cache= GET_CACHE(re, &s->gb);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3788 if (cache&0x80000000) {
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3789 if (cache&0x40000000) {
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3790 /* third escape */
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3791 SKIP_CACHE(re, &s->gb, 2);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3792 last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3793 run= SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3794 SKIP_COUNTER(re, &s->gb, 2+1+6);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3795 UPDATE_CACHE(re, &s->gb);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3796
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3797 if(SHOW_UBITS(re, &s->gb, 1)==0){
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3798 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
3799 return -1;
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3800 }; SKIP_CACHE(re, &s->gb, 1);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3801
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3802 level= SHOW_SBITS(re, &s->gb, 12); SKIP_CACHE(re, &s->gb, 12);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3803
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3804 if(SHOW_UBITS(re, &s->gb, 1)==0){
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3805 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
3806 return -1;
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3807 }; LAST_SKIP_CACHE(re, &s->gb, 1);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3808
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3809 SKIP_COUNTER(re, &s->gb, 1+12+1);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3810
597
d5d0c11ea4cf fixing level overflow check for qp=1
michaelni
parents: 591
diff changeset
3811 if(level*s->qscale>1024 || level*s->qscale<-1024){
d5d0c11ea4cf fixing level overflow check for qp=1
michaelni
parents: 591
diff changeset
3812 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
3813 return -1;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3814 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3815 #if 1
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3816 {
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3817 const int abs_level= ABS(level);
921
f633377858b6 ump4 decoding fixed
michaelni
parents: 906
diff changeset
3818 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
3819 const int run1= run - rl->max_run[last][abs_level] - 1;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3820 if(abs_level <= rl->max_level[last][run]){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3821 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
3822 return -1;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3823 }
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
3824 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
3825 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
3826 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
3827 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
3828 }
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
3829 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
3830 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
3831 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
3832 }
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3833 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3834 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3835 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3836 #endif
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3837 if (level>0) level= level * qmul + qadd;
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3838 else level= level * qmul - qadd;
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3839
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3840 i+= run + 1;
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3841 if(last) i+=192;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3842 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
3843 /* second escape */
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3844 #if MIN_CACHE_BITS < 20
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3845 LAST_SKIP_BITS(re, &s->gb, 2);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3846 UPDATE_CACHE(re, &s->gb);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3847 #else
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3848 SKIP_BITS(re, &s->gb, 2);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3849 #endif
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3850 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3851 i+= run + rl->max_run[run>>7][level/qmul] +1; //FIXME opt indexing
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3852 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3853 LAST_SKIP_BITS(re, &s->gb, 1);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3854 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
3855 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
3856 /* first escape */
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3857 #if MIN_CACHE_BITS < 19
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3858 LAST_SKIP_BITS(re, &s->gb, 1);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3859 UPDATE_CACHE(re, &s->gb);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3860 #else
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3861 SKIP_BITS(re, &s->gb, 1);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3862 #endif
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3863 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3864 i+= run;
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3865 level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//FIXME opt indexing
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3866 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3867 LAST_SKIP_BITS(re, &s->gb, 1);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3868 }
1132
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
3869 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3870 } else {
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3871 i+= run;
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3872 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3873 LAST_SKIP_BITS(re, &s->gb, 1);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3874 }
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3875 if (i > 62){
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3876 i-= 192;
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3877 if(i&(~63)){
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3878 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
3879 return -1;
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3880 }
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3881
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3882 block[scan_table[i]] = level;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3883 break;
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3884 }
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3885
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3886 block[scan_table[i]] = level;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3887 }
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3888 CLOSE_READER(re, &s->gb);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3889 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3890 not_coded:
986e461dc072 Initial revision
glantau
parents:
diff changeset
3891 if (s->mb_intra) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
3892 mpeg4_pred_ac(s, block, n, dc_pred_dir);
986e461dc072 Initial revision
glantau
parents:
diff changeset
3893 if (s->ac_pred) {
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3894 i = 63; /* XXX: not optimal */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3895 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
3896 }
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
3897 s->block_last_index[n] = i;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3898 return 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3899 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
3900
986e461dc072 Initial revision
glantau
parents:
diff changeset
3901 /* most is hardcoded. should extend to handle all h263 streams */
986e461dc072 Initial revision
glantau
parents:
diff changeset
3902 int h263_decode_picture_header(MpegEncContext *s)
986e461dc072 Initial revision
glantau
parents:
diff changeset
3903 {
986e461dc072 Initial revision
glantau
parents:
diff changeset
3904 int format, width, height;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3905
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3906 /* picture start code */
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3907 if (get_bits(&s->gb, 22) != 0x20) {
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3908 fprintf(stderr, "Bad picture start code\n");
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3909 return -1;
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3910 }
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3911 /* temporal reference */
231
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
3912 s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3913
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3914 /* PTYPE starts here */
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3915 if (get_bits1(&s->gb) != 1) {
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3916 /* marker */
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3917 fprintf(stderr, "Bad marker\n");
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3918 return -1;
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3919 }
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3920 if (get_bits1(&s->gb) != 0) {
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3921 fprintf(stderr, "Bad H263 id\n");
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3922 return -1; /* h263 id */
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3923 }
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
3924 skip_bits1(&s->gb); /* split screen off */
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
3925 skip_bits1(&s->gb); /* camera off */
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
3926 skip_bits1(&s->gb); /* freeze picture release off */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3927
155
3c3449bce692 - Bug fix on MV prediction for MPEG4 caused by new H.263 GOB code.
pulento
parents: 154
diff changeset
3928 /* Reset GOB number */
154
f914f710b8d0 - Fixed a bug on H.263 MV prediction for MB on GOBs limits.
pulento
parents: 144
diff changeset
3929 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
3930
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3931 format = get_bits(&s->gb, 3);
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3932 /*
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3933 0 forbidden
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3934 1 sub-QCIF
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3935 10 QCIF
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3936 7 extended PTYPE (PLUSPTYPE)
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3937 */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3938
161
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3939 if (format != 7 && format != 6) {
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3940 s->h263_plus = 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3941 /* H.263v1 */
986e461dc072 Initial revision
glantau
parents:
diff changeset
3942 width = h263_format[format][0];
986e461dc072 Initial revision
glantau
parents:
diff changeset
3943 height = h263_format[format][1];
986e461dc072 Initial revision
glantau
parents:
diff changeset
3944 if (!width)
986e461dc072 Initial revision
glantau
parents:
diff changeset
3945 return -1;
161
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3946
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3947 s->width = width;
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3948 s->height = height;
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
3949 s->pict_type = I_TYPE + get_bits1(&s->gb);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3950
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
3951 s->unrestricted_mv = get_bits1(&s->gb);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3952 s->h263_long_vectors = s->unrestricted_mv;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3953
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3954 if (get_bits1(&s->gb) != 0) {
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3955 fprintf(stderr, "H263 SAC not supported\n");
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3956 return -1; /* SAC: off */
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3957 }
161
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3958 if (get_bits1(&s->gb) != 0) {
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3959 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
3960 }
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3961
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3962 if (get_bits1(&s->gb) != 0) {
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3963 fprintf(stderr, "H263 PB frame not supported\n");
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3964 return -1; /* not PB frame */
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3965 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3966 s->qscale = get_bits(&s->gb, 5);
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
3967 skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3968 } else {
161
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3969 int ufep;
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3970
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3971 /* H.263v2 */
161
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3972 s->h263_plus = 1;
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3973 ufep = get_bits(&s->gb, 3); /* Update Full Extended PTYPE */
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3974
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3975 /* 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
3976 if (ufep == 1) {
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3977 /* OPPTYPE */
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3978 format = get_bits(&s->gb, 3);
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3979 dprintf("ufep=1, format: %d\n", format);
161
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3980 skip_bits(&s->gb,1); /* Custom PCF */
1089
7e79a58954b1 h263(+) clenaup & bugfixes
michaelni
parents: 1070
diff changeset
3981 s->umvplus = get_bits(&s->gb, 1); /* Unrestricted Motion Vector */
161
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3982 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
3983 if (get_bits1(&s->gb) != 0) {
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
3984 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
3985 }
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
3986 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
3987 s->h263_aic = 1;
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
3988 }
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3989
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
3990 skip_bits(&s->gb, 7);
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3991 /* these are the 7 bits: (in order of appearence */
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3992 /* Deblocking Filter */
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3993 /* Slice Structured */
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3994 /* Reference Picture Selection */
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3995 /* Independent Segment Decoding */
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3996 /* Alternative Inter VLC */
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3997 /* Modified Quantization */
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3998 /* Prevent start code emulation */
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
3999
161
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
4000 skip_bits(&s->gb, 3); /* Reserved */
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4001 } else if (ufep != 0) {
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4002 fprintf(stderr, "Bad UFEP type (%d)\n", ufep);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4003 return -1;
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4004 }
161
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
4005
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
4006 /* MPPTYPE */
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4007 s->pict_type = get_bits(&s->gb, 3) + I_TYPE;
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4008 dprintf("pict_type: %d\n", s->pict_type);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4009 if (s->pict_type != I_TYPE &&
986e461dc072 Initial revision
glantau
parents:
diff changeset
4010 s->pict_type != P_TYPE)
986e461dc072 Initial revision
glantau
parents:
diff changeset
4011 return -1;
250
3449316664b5 - Bug fix on RTYPE (rounding type) not being honoured by H.263+ decoder.
pulento
parents: 249
diff changeset
4012 skip_bits(&s->gb, 2);
3449316664b5 - Bug fix on RTYPE (rounding type) not being honoured by H.263+ decoder.
pulento
parents: 249
diff changeset
4013 s->no_rounding = get_bits1(&s->gb);
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4014 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
4015 skip_bits(&s->gb, 4);
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
4016
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
4017 /* Get the picture dimensions */
161
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
4018 if (ufep) {
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
4019 if (format == 6) {
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
4020 /* Custom Picture Format (CPFMT) */
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4021 s->aspect_ratio_info = get_bits(&s->gb, 4);
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4022 dprintf("aspect: %d\n", s->aspect_ratio_info);
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4023 /* aspect ratios:
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4024 0 - forbidden
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4025 1 - 1:1
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4026 2 - 12:11 (CIF 4:3)
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4027 3 - 10:11 (525-type 4:3)
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4028 4 - 16:11 (CIF 16:9)
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4029 5 - 40:33 (525-type 16:9)
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4030 6-14 - reserved
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4031 */
161
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
4032 width = (get_bits(&s->gb, 9) + 1) * 4;
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
4033 skip_bits1(&s->gb);
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
4034 height = get_bits(&s->gb, 9) * 4;
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4035 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
4036 if (s->aspect_ratio_info == FF_ASPECT_EXTENDED) {
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4037 /* aspected dimensions */
669
b4bddbde44f3 aspect (ext. par too) support for h263 and mpeg4 (inc. build becouse of new vars)
al3x
parents: 667
diff changeset
4038 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
4039 s->aspected_height = get_bits(&s->gb, 8);
887
19f5b8b7c6d5 fixing aspect
michaelni
parents: 880
diff changeset
4040 }else{
19f5b8b7c6d5 fixing aspect
michaelni
parents: 880
diff changeset
4041 s->aspected_width = pixel_aspect[s->aspect_ratio_info][0];
19f5b8b7c6d5 fixing aspect
michaelni
parents: 880
diff changeset
4042 s->aspected_height= pixel_aspect[s->aspect_ratio_info][1];
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4043 }
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4044 } else {
161
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
4045 width = h263_format[format][0];
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
4046 height = h263_format[format][1];
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
4047 }
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
4048 if ((width == 0) || (height == 0))
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
4049 return -1;
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
4050 s->width = width;
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
4051 s->height = height;
1089
7e79a58954b1 h263(+) clenaup & bugfixes
michaelni
parents: 1070
diff changeset
4052 if (s->umvplus) {
7e79a58954b1 h263(+) clenaup & bugfixes
michaelni
parents: 1070
diff changeset
4053 if(get_bits1(&s->gb)==0) /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
7e79a58954b1 h263(+) clenaup & bugfixes
michaelni
parents: 1070
diff changeset
4054 skip_bits1(&s->gb);
161
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
4055 }
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
4056 }
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
4057
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4058 s->qscale = get_bits(&s->gb, 5);
986e461dc072 Initial revision
glantau
parents:
diff changeset
4059 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
4060 /* PEI */
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
4061 while (get_bits1(&s->gb) != 0) {
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
4062 skip_bits(&s->gb, 8);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4063 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
4064 s->f_code = 1;
498
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
4065
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
4066 if(s->h263_aic){
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
4067 s->y_dc_scale_table=
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
4068 s->c_dc_scale_table= h263_aic_dc_scale_table;
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
4069 }else{
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
4070 s->y_dc_scale_table=
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
4071 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
4072 }
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
4073
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4074 return 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
4075 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
4076
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
4077 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
4078 {
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
4079 int i;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
4080 int a= 2<<s->sprite_warping_accuracy;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
4081 int rho= 3-s->sprite_warping_accuracy;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
4082 int r=16/a;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
4083 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
4084 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
4085 int sprite_ref[4][2];
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
4086 int virtual_ref[2][2];
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4087 int w2, h2, w3, h3;
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
4088 int alpha=0, beta=0;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
4089 int w= s->width;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
4090 int h= s->height;
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4091 int min_ab;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4092
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
4093 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
4094 int length;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
4095 int x=0, y=0;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
4096
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
4097 length= get_vlc(&s->gb, &sprite_trajectory);
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
4098 if(length){
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
4099 x= get_bits(&s->gb, length);
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4100
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
4101 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
4102 x = - (x ^ ((1 << length) - 1));
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
4103 }
255
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
4104 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
4105
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
4106 length= get_vlc(&s->gb, &sprite_trajectory);
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
4107 if(length){
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
4108 y=get_bits(&s->gb, length);
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4109
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
4110 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
4111 y = - (y ^ ((1 << length) - 1));
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
4112 }
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
4113 skip_bits1(&s->gb); /* marker bit */
255
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
4114 //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
4115 d[i][0]= x;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
4116 d[i][1]= y;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
4117 }
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
4118
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
4119 while((1<<alpha)<w) alpha++;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
4120 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
4121 w2= 1<<alpha;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
4122 h2= 1<<beta;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
4123
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
4124 // Note, the 4th point isnt used for GMC
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
4125 if(s->divx_version==500 && s->divx_build==413){
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
4126 sprite_ref[0][0]= a*vop_ref[0][0] + d[0][0];
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
4127 sprite_ref[0][1]= a*vop_ref[0][1] + d[0][1];
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
4128 sprite_ref[1][0]= a*vop_ref[1][0] + d[0][0] + d[1][0];
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
4129 sprite_ref[1][1]= a*vop_ref[1][1] + d[0][1] + d[1][1];
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
4130 sprite_ref[2][0]= a*vop_ref[2][0] + d[0][0] + d[2][0];
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
4131 sprite_ref[2][1]= a*vop_ref[2][1] + d[0][1] + d[2][1];
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
4132 } else {
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
4133 sprite_ref[0][0]= (a>>1)*(2*vop_ref[0][0] + d[0][0]);
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
4134 sprite_ref[0][1]= (a>>1)*(2*vop_ref[0][1] + d[0][1]);
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
4135 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
4136 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
4137 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
4138 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
4139 }
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
4140 /* 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
4141 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
4142
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
4143 // 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
4144 // 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
4145 // 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
4146 // 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
4147 virtual_ref[0][0]= 16*(vop_ref[0][0] + w2)
359
df0736462b9f move ABS() to common.h
michaelni
parents: 358
diff changeset
4148 + 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
4149 virtual_ref[0][1]= 16*vop_ref[0][1]
359
df0736462b9f move ABS() to common.h
michaelni
parents: 358
diff changeset
4150 + 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
4151 virtual_ref[1][0]= 16*vop_ref[0][0]
359
df0736462b9f move ABS() to common.h
michaelni
parents: 358
diff changeset
4152 + 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
4153 virtual_ref[1][1]= 16*(vop_ref[0][1] + h2)
359
df0736462b9f move ABS() to common.h
michaelni
parents: 358
diff changeset
4154 + 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
4155
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
4156 switch(s->num_sprite_warping_points)
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
4157 {
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
4158 case 0:
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
4159 s->sprite_offset[0][0]= 0;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
4160 s->sprite_offset[0][1]= 0;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
4161 s->sprite_offset[1][0]= 0;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
4162 s->sprite_offset[1][1]= 0;
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4163 s->sprite_delta[0][0]= a;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4164 s->sprite_delta[0][1]= 0;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4165 s->sprite_delta[1][0]= 0;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4166 s->sprite_delta[1][1]= a;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4167 s->sprite_shift[0]= 0;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4168 s->sprite_shift[1]= 0;
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
4169 break;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
4170 case 1: //GMC only
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
4171 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
4172 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
4173 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
4174 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
4175 s->sprite_delta[0][0]= a;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4176 s->sprite_delta[0][1]= 0;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4177 s->sprite_delta[1][0]= 0;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4178 s->sprite_delta[1][1]= a;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4179 s->sprite_shift[0]= 0;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4180 s->sprite_shift[1]= 0;
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
4181 break;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
4182 case 2:
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
4183 s->sprite_offset[0][0]= (sprite_ref[0][0]<<(alpha+rho))
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4184 + (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][0])
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4185 + ( r*sprite_ref[0][1] - virtual_ref[0][1])*(-vop_ref[0][1])
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4186 + (1<<(alpha+rho-1));
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
4187 s->sprite_offset[0][1]= (sprite_ref[0][1]<<(alpha+rho))
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4188 + (-r*sprite_ref[0][1] + virtual_ref[0][1])*(-vop_ref[0][0])
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4189 + (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][1])
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4190 + (1<<(alpha+rho-1));
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4191 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
4192 +( 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
4193 +2*w2*r*sprite_ref[0][0]
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4194 - 16*w2
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4195 + (1<<(alpha+rho+1)));
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4196 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
4197 +(-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
4198 +2*w2*r*sprite_ref[0][1]
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4199 - 16*w2
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4200 + (1<<(alpha+rho+1)));
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4201 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
4202 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
4203 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
4204 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
4205
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4206 s->sprite_shift[0]= alpha+rho;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4207 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
4208 break;
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4209 case 3:
847
f3c369b8ddca reversing header game
michaelni
parents: 821
diff changeset
4210 min_ab= FFMIN(alpha, beta);
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4211 w3= w2>>min_ab;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4212 h3= h2>>min_ab;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4213 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
4214 + (-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
4215 + (-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
4216 + (1<<(alpha+beta+rho-min_ab-1));
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4217 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
4218 + (-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
4219 + (-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
4220 + (1<<(alpha+beta+rho-min_ab-1));
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4221 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
4222 + (-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
4223 + 2*w2*h3*r*sprite_ref[0][0]
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4224 - 16*w2*h3
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4225 + (1<<(alpha+beta+rho-min_ab+1));
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4226 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
4227 + (-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
4228 + 2*w2*h3*r*sprite_ref[0][1]
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4229 - 16*w2*h3
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4230 + (1<<(alpha+beta+rho-min_ab+1));
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4231 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
4232 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
4233 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
4234 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
4235
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4236 s->sprite_shift[0]= alpha + beta + rho - min_ab;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4237 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
4238 break;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
4239 }
255
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
4240 /* try to simplify the situation */
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4241 if( s->sprite_delta[0][0] == a<<s->sprite_shift[0]
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4242 && s->sprite_delta[0][1] == 0
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4243 && s->sprite_delta[1][0] == 0
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4244 && s->sprite_delta[1][1] == a<<s->sprite_shift[0])
255
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
4245 {
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4246 s->sprite_offset[0][0]>>=s->sprite_shift[0];
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4247 s->sprite_offset[0][1]>>=s->sprite_shift[0];
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4248 s->sprite_offset[1][0]>>=s->sprite_shift[1];
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4249 s->sprite_offset[1][1]>>=s->sprite_shift[1];
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4250 s->sprite_delta[0][0]= a;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4251 s->sprite_delta[0][1]= 0;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4252 s->sprite_delta[1][0]= 0;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4253 s->sprite_delta[1][1]= a;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4254 s->sprite_shift[0]= 0;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4255 s->sprite_shift[1]= 0;
255
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
4256 s->real_sprite_warping_points=1;
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
4257 }
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4258 else{
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4259 int shift_y= 16 - s->sprite_shift[0];
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4260 int shift_c= 16 - s->sprite_shift[1];
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4261 //printf("shifts %d %d\n", shift_y, shift_c);
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4262 for(i=0; i<2; i++){
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4263 s->sprite_offset[0][i]<<= shift_y;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4264 s->sprite_offset[1][i]<<= shift_c;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4265 s->sprite_delta[0][i]<<= shift_y;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4266 s->sprite_delta[1][i]<<= shift_y;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4267 s->sprite_shift[i]= 16;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4268 }
255
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
4269 s->real_sprite_warping_points= s->num_sprite_warping_points;
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4270 }
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4271 #if 0
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4272 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
4273 vop_ref[0][0], vop_ref[0][1],
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4274 vop_ref[1][0], vop_ref[1][1],
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4275 vop_ref[2][0], vop_ref[2][1],
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4276 sprite_ref[0][0], sprite_ref[0][1],
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4277 sprite_ref[1][0], sprite_ref[1][1],
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4278 sprite_ref[2][0], sprite_ref[2][1],
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4279 virtual_ref[0][0], virtual_ref[0][1],
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4280 virtual_ref[1][0], virtual_ref[1][1]
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4281 );
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4282
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4283 printf("offset: %d:%d , delta: %d %d %d %d, shift %d\n",
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4284 s->sprite_offset[0][0], s->sprite_offset[0][1],
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4285 s->sprite_delta[0][0], s->sprite_delta[0][1],
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4286 s->sprite_delta[1][0], s->sprite_delta[1][1],
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4287 s->sprite_shift[0]
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4288 );
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4289 #endif
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
4290 }
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
4291
942
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
4292 static int mpeg4_decode_gop_header(MpegEncContext * s, GetBitContext *gb){
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
4293 int hours, minutes, seconds;
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
4294
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
4295 hours= get_bits(gb, 5);
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
4296 minutes= get_bits(gb, 6);
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
4297 skip_bits1(gb);
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
4298 seconds= get_bits(gb, 6);
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
4299
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
4300 s->time_base= seconds + 60*(minutes + 60*hours);
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
4301
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
4302 skip_bits1(gb);
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
4303 skip_bits1(gb);
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
4304
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
4305 return 0;
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
4306 }
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
4307
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4308 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
4309 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
4310
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4311 /* vol header */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4312 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
4313 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
4314 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
4315 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
4316 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
4317 } else {
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4318 vo_ver_id = 1;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4319 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4320 //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
4321 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
4322 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
4323 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
4324 s->aspected_height = get_bits(gb, 8); // par_height
887
19f5b8b7c6d5 fixing aspect
michaelni
parents: 880
diff changeset
4325 }else{
19f5b8b7c6d5 fixing aspect
michaelni
parents: 880
diff changeset
4326 s->aspected_width = pixel_aspect[s->aspect_ratio_info][0];
19f5b8b7c6d5 fixing aspect
michaelni
parents: 880
diff changeset
4327 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
4328 }
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 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
4331 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
4332 if(chroma_format!=1){
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4333 printf("illegal chroma format\n");
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 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
4336 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
4337 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
4338 skip_bits1(gb); /* marker */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4339 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
4340 skip_bits1(gb); /* marker */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4341 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
4342 skip_bits1(gb); /* marker */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4343 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
4344 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
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 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
4347 skip_bits1(gb); /* marker */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4348 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4349 }else{
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4350 // 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
4351 if(s->picture_number==0)
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4352 s->low_delay=0;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4353 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4354
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4355 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
4356 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
4357 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
4358 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
4359 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
4360 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4361
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4362 skip_bits1(gb); /* marker */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4363
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4364 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
4365
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4366 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
4367 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
4368 s->time_increment_bits = 1;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4369 skip_bits1(gb); /* marker */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4370
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4371 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
4372 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
4373 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4374
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4375 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
4376 if (s->shape == RECT_SHAPE) {
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4377 skip_bits1(gb); /* marker */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4378 width = get_bits(gb, 13);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4379 skip_bits1(gb); /* marker */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4380 height = get_bits(gb, 13);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4381 skip_bits1(gb); /* marker */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4382 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
4383 s->width = width;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4384 s->height = height;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4385 // 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
4386 }
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
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4389 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
4390 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
4391 if (vo_ver_id == 1) {
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4392 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
4393 } else {
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4394 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
4395 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4396 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
4397 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
4398 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
4399 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
4400 skip_bits1(gb); /* marker */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4401 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
4402 skip_bits1(gb); /* marker */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4403 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
4404 skip_bits1(gb); /* marker */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4405 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
4406 skip_bits1(gb); /* marker */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4407 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4408 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
4409 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
4410 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
4411 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
4412 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
4413 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4414 // 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
4415
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4416 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
4417 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
4418 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
4419 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
4420 } else {
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4421 s->quant_precision = 5;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4422 }
747
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 // 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
4425
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4426 if((s->mpeg_quant=get_bits1(gb))){ /* vol_quant_type */
1057
bb5de8a59da8 * static,const,compiler warning cleanup
kabi
parents: 1053
diff changeset
4427 int i, v;
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4428
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4429 /* load default matrixes */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4430 for(i=0; i<64; i++){
1092
f59c3f66363b MpegEncContext.(i)dct_* -> DspContext.(i)dct_*
michaelni
parents: 1090
diff changeset
4431 int j= s->dsp.idct_permutation[i];
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4432 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
4433 s->intra_matrix[j]= v;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4434 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
4435
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4436 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
4437 s->inter_matrix[j]= v;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4438 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
4439 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4440
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4441 /* load custom intra matrix */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4442 if(get_bits1(gb)){
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4443 int last=0;
1057
bb5de8a59da8 * static,const,compiler warning cleanup
kabi
parents: 1053
diff changeset
4444 for(i=0; i<64; i++){
bb5de8a59da8 * static,const,compiler warning cleanup
kabi
parents: 1053
diff changeset
4445 int j;
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4446 v= get_bits(gb, 8);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4447 if(v==0) break;
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 last= v;
1092
f59c3f66363b MpegEncContext.(i)dct_* -> DspContext.(i)dct_*
michaelni
parents: 1090
diff changeset
4450 j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4451 s->intra_matrix[j]= v;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4452 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
4453 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4454
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4455 /* replicate last value */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4456 for(; i<64; i++){
1092
f59c3f66363b MpegEncContext.(i)dct_* -> DspContext.(i)dct_*
michaelni
parents: 1090
diff changeset
4457 int j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4458 s->intra_matrix[j]= v;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4459 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
4460 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4461 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4462
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4463 /* load custom non intra matrix */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4464 if(get_bits1(gb)){
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4465 int last=0;
1057
bb5de8a59da8 * static,const,compiler warning cleanup
kabi
parents: 1053
diff changeset
4466 for(i=0; i<64; i++){
bb5de8a59da8 * static,const,compiler warning cleanup
kabi
parents: 1053
diff changeset
4467 int j;
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4468 v= get_bits(gb, 8);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4469 if(v==0) break;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4470
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4471 last= v;
1092
f59c3f66363b MpegEncContext.(i)dct_* -> DspContext.(i)dct_*
michaelni
parents: 1090
diff changeset
4472 j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4473 s->inter_matrix[j]= v;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4474 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
4475 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4476
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4477 /* replicate last value */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4478 for(; i<64; i++){
1092
f59c3f66363b MpegEncContext.(i)dct_* -> DspContext.(i)dct_*
michaelni
parents: 1090
diff changeset
4479 int j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4480 s->inter_matrix[j]= last;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4481 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
4482 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4483 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4484
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4485 // 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
4486 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4487
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4488 if(vo_ver_id != 1)
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4489 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
4490 else s->quarter_sample=0;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4491
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4492 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
4493
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4494 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
4495
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4496 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
4497 if(s->data_partitioning){
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4498 s->rvlc= get_bits1(gb);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4499 }
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(vo_ver_id != 1) {
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4502 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
4503 if(s->new_pred){
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4504 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
4505 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
4506 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
4507 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4508 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
4509 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
4510 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4511 else{
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4512 s->new_pred=0;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4513 s->reduced_res_vop= 0;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4514 }
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 s->scalability= get_bits1(gb);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4517
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4518 if (s->scalability) {
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4519 GetBitContext bak= *gb;
751
cbe316f082bc warning fixes
michaelni
parents: 747
diff changeset
4520 int ref_layer_id;
cbe316f082bc warning fixes
michaelni
parents: 747
diff changeset
4521 int ref_layer_sampling_dir;
cbe316f082bc warning fixes
michaelni
parents: 747
diff changeset
4522 int h_sampling_factor_n;
cbe316f082bc warning fixes
michaelni
parents: 747
diff changeset
4523 int h_sampling_factor_m;
cbe316f082bc warning fixes
michaelni
parents: 747
diff changeset
4524 int v_sampling_factor_n;
cbe316f082bc warning fixes
michaelni
parents: 747
diff changeset
4525 int v_sampling_factor_m;
cbe316f082bc warning fixes
michaelni
parents: 747
diff changeset
4526
cbe316f082bc warning fixes
michaelni
parents: 747
diff changeset
4527 s->hierachy_type= get_bits1(gb);
cbe316f082bc warning fixes
michaelni
parents: 747
diff changeset
4528 ref_layer_id= get_bits(gb, 4);
cbe316f082bc warning fixes
michaelni
parents: 747
diff changeset
4529 ref_layer_sampling_dir= get_bits1(gb);
cbe316f082bc warning fixes
michaelni
parents: 747
diff changeset
4530 h_sampling_factor_n= get_bits(gb, 5);
cbe316f082bc warning fixes
michaelni
parents: 747
diff changeset
4531 h_sampling_factor_m= get_bits(gb, 5);
cbe316f082bc warning fixes
michaelni
parents: 747
diff changeset
4532 v_sampling_factor_n= get_bits(gb, 5);
cbe316f082bc warning fixes
michaelni
parents: 747
diff changeset
4533 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
4534 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
4535
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4536 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
4537 || 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
4538
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4539 // 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
4540 s->scalability=0;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4541
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4542 *gb= bak;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4543 }else
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4544 printf("scalability not supported\n");
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4545
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4546 // bin shape stuff FIXME
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4547 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4548 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4549 return 0;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4550 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4551
1034
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
4552 /**
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
4553 * decodes the user data stuff in the header.
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
4554 * allso inits divx/xvid/lavc_version/build
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
4555 */
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4556 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
4557 char buf[256];
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4558 int i;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4559 int e;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4560 int ver, build, ver2, ver3;
1145
79e8ed620b17 better non conformant divx packed bitstream detection, so unpacked (no b frames) divx MPEG4-ES streams can be read
michaelni
parents: 1144
diff changeset
4561 char last;
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4562
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4563 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
4564 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
4565 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
4566 if(buf[i]==0) break;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4567 skip_bits(gb, 8);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4568 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4569 buf[255]=0;
1145
79e8ed620b17 better non conformant divx packed bitstream detection, so unpacked (no b frames) divx MPEG4-ES streams can be read
michaelni
parents: 1144
diff changeset
4570
761
7f4cc2f6d642 xvid qpel bug autodetect
michaelni
parents: 757
diff changeset
4571 /* divx detection */
1145
79e8ed620b17 better non conformant divx packed bitstream detection, so unpacked (no b frames) divx MPEG4-ES streams can be read
michaelni
parents: 1144
diff changeset
4572 e=sscanf(buf, "DivX%dBuild%d%c", &ver, &build, &last);
79e8ed620b17 better non conformant divx packed bitstream detection, so unpacked (no b frames) divx MPEG4-ES streams can be read
michaelni
parents: 1144
diff changeset
4573 if(e<2)
79e8ed620b17 better non conformant divx packed bitstream detection, so unpacked (no b frames) divx MPEG4-ES streams can be read
michaelni
parents: 1144
diff changeset
4574 e=sscanf(buf, "DivX%db%d%c", &ver, &build, &last);
79e8ed620b17 better non conformant divx packed bitstream detection, so unpacked (no b frames) divx MPEG4-ES streams can be read
michaelni
parents: 1144
diff changeset
4575 if(e>=2){
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4576 s->divx_version= ver;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4577 s->divx_build= build;
1145
79e8ed620b17 better non conformant divx packed bitstream detection, so unpacked (no b frames) divx MPEG4-ES streams can be read
michaelni
parents: 1144
diff changeset
4578 s->divx_packed= e==3 && last=='p';
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4579 if(s->picture_number==0){
1145
79e8ed620b17 better non conformant divx packed bitstream detection, so unpacked (no b frames) divx MPEG4-ES streams can be read
michaelni
parents: 1144
diff changeset
4580 printf("This file was encoded with DivX%d Build%d", ver, build);
79e8ed620b17 better non conformant divx packed bitstream detection, so unpacked (no b frames) divx MPEG4-ES streams can be read
michaelni
parents: 1144
diff changeset
4581 if(s->divx_packed)
79e8ed620b17 better non conformant divx packed bitstream detection, so unpacked (no b frames) divx MPEG4-ES streams can be read
michaelni
parents: 1144
diff changeset
4582 printf("p\n");
79e8ed620b17 better non conformant divx packed bitstream detection, so unpacked (no b frames) divx MPEG4-ES streams can be read
michaelni
parents: 1144
diff changeset
4583 else
79e8ed620b17 better non conformant divx packed bitstream detection, so unpacked (no b frames) divx MPEG4-ES streams can be read
michaelni
parents: 1144
diff changeset
4584 printf("\n");
263
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
4585 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4586 }
761
7f4cc2f6d642 xvid qpel bug autodetect
michaelni
parents: 757
diff changeset
4587
7f4cc2f6d642 xvid qpel bug autodetect
michaelni
parents: 757
diff changeset
4588 /* ffmpeg detection */
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4589 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
4590 if(e!=4)
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4591 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
4592 if(e!=4){
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4593 if(strcmp(buf, "ffmpeg")==0){
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4594 s->ffmpeg_version= 0x000406;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4595 s->lavc_build= 4600;
63
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
4596 }
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4597 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4598 if(e==4){
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4599 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
4600 s->lavc_build= build;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4601 if(s->picture_number==0)
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4602 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
4603 }
761
7f4cc2f6d642 xvid qpel bug autodetect
michaelni
parents: 757
diff changeset
4604
7f4cc2f6d642 xvid qpel bug autodetect
michaelni
parents: 757
diff changeset
4605 /* xvid detection */
7f4cc2f6d642 xvid qpel bug autodetect
michaelni
parents: 757
diff changeset
4606 e=sscanf(buf, "XviD%d", &build);
7f4cc2f6d642 xvid qpel bug autodetect
michaelni
parents: 757
diff changeset
4607 if(e==1){
7f4cc2f6d642 xvid qpel bug autodetect
michaelni
parents: 757
diff changeset
4608 s->xvid_build= build;
7f4cc2f6d642 xvid qpel bug autodetect
michaelni
parents: 757
diff changeset
4609 if(s->picture_number==0)
7f4cc2f6d642 xvid qpel bug autodetect
michaelni
parents: 757
diff changeset
4610 printf("This file was encoded with XviD build %d\n", build);
7f4cc2f6d642 xvid qpel bug autodetect
michaelni
parents: 757
diff changeset
4611 }
7f4cc2f6d642 xvid qpel bug autodetect
michaelni
parents: 757
diff changeset
4612
255
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
4613 //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
4614 return 0;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4615 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4616
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4617 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
4618 int time_incr, time_increment;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4619
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4620 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
4621 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
4622 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
4623 s->low_delay=0;
fdeec2834c79 there are divx5? encoded files without a userdata section but with b-frames :(
michaelni
parents: 364
diff changeset
4624 }
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4625
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
4626 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
4627 if(s->partitioned_frame)
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
4628 s->decode_mb= mpeg4_decode_partitioned_mb;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
4629 else
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
4630 s->decode_mb= ff_h263_decode_mb;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
4631
662
5a158f0d1981 fixing 1/0 if the headers are incomplete (like what M$ encoder generates)
michaelni
parents: 661
diff changeset
4632 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
4633 s->time_increment_resolution=1;
5a158f0d1981 fixing 1/0 if the headers are incomplete (like what M$ encoder generates)
michaelni
parents: 661
diff changeset
4634 // 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
4635 }
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
4636 time_incr=0;
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4637 while (get_bits1(gb) != 0)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4638 time_incr++;
986e461dc072 Initial revision
glantau
parents:
diff changeset
4639
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4640 check_marker(gb, "before time_increment");
1068
a5be963709d1 improving parsing of incomplete headers
michaelni
parents: 1064
diff changeset
4641
a5be963709d1 improving parsing of incomplete headers
michaelni
parents: 1064
diff changeset
4642 if(s->picture_number==0 && (show_bits(gb, s->time_increment_bits+1)&1)==0){
a5be963709d1 improving parsing of incomplete headers
michaelni
parents: 1064
diff changeset
4643 printf("hmm, seems the headers arnt complete, trying to guess time_increment_bits\n");
a5be963709d1 improving parsing of incomplete headers
michaelni
parents: 1064
diff changeset
4644
a5be963709d1 improving parsing of incomplete headers
michaelni
parents: 1064
diff changeset
4645
a5be963709d1 improving parsing of incomplete headers
michaelni
parents: 1064
diff changeset
4646 for(s->time_increment_bits=1 ;s->time_increment_bits<16; s->time_increment_bits++){
a5be963709d1 improving parsing of incomplete headers
michaelni
parents: 1064
diff changeset
4647 if(show_bits(gb, s->time_increment_bits+1)&1) break;
a5be963709d1 improving parsing of incomplete headers
michaelni
parents: 1064
diff changeset
4648 }
a5be963709d1 improving parsing of incomplete headers
michaelni
parents: 1064
diff changeset
4649 printf("my guess is %d bits ;)\n",s->time_increment_bits);
a5be963709d1 improving parsing of incomplete headers
michaelni
parents: 1064
diff changeset
4650 }
a5be963709d1 improving parsing of incomplete headers
michaelni
parents: 1064
diff changeset
4651
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4652 time_increment= get_bits(gb, s->time_increment_bits);
697
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
4653 //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
4654 if(s->pict_type!=B_TYPE){
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
4655 s->last_time_base= s->time_base;
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
4656 s->time_base+= time_incr;
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
4657 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
4658 if(s->workaround_bugs&FF_BUG_UMP4){
700
0fb4c66527e1 autodetect UMP4 (by adding a fourcc field to AVCodecContext)
michaelni
parents: 699
diff changeset
4659 if(s->time < s->last_non_b_time){
0fb4c66527e1 autodetect UMP4 (by adding a fourcc field to AVCodecContext)
michaelni
parents: 699
diff changeset
4660 // 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
4661 s->time_base++;
0fb4c66527e1 autodetect UMP4 (by adding a fourcc field to AVCodecContext)
michaelni
parents: 699
diff changeset
4662 s->time+= s->time_increment_resolution;
0fb4c66527e1 autodetect UMP4 (by adding a fourcc field to AVCodecContext)
michaelni
parents: 699
diff changeset
4663 }
664
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
4664 }
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
4665 s->pp_time= s->time - s->last_non_b_time;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
4666 s->last_non_b_time= s->time;
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
4667 }else{
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
4668 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
4669 s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
4670 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
4671 // printf("messed up order, seeking?, skiping current b frame\n");
e7e9d9901523 b-frame mpeg4 fix when seeking
michaelni
parents: 333
diff changeset
4672 return FRAME_SKIPED;
e7e9d9901523 b-frame mpeg4 fix when seeking
michaelni
parents: 333
diff changeset
4673 }
664
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
4674
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
4675 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
4676 if(s->t_frame==0) s->t_frame=1; // 1/0 protection
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
4677 //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
4678 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
4679 - 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
4680 s->pb_field_time= ( ROUNDED_DIV(s->time, s->t_frame)
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
4681 - ROUNDED_DIV(s->last_non_b_time - s->pp_time, s->t_frame))*2;
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
4682 }
654
850098147a3c export pts from stream if available
michaelni
parents: 648
diff changeset
4683
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
4684 s->current_picture.pts= s->time*1000LL*1000LL / s->time_increment_resolution;
942
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
4685 if(s->avctx->debug&FF_DEBUG_PTS)
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
4686 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
4687
1068
a5be963709d1 improving parsing of incomplete headers
michaelni
parents: 1064
diff changeset
4688 check_marker(gb, "before vop_coded");
a5be963709d1 improving parsing of incomplete headers
michaelni
parents: 1064
diff changeset
4689
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4690 /* vop coded */
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4691 if (get_bits1(gb) != 1){
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4692 printf("vop not coded\n");
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4693 return FRAME_SKIPED;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4694 }
664
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
4695 //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
4696 //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
4697 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
4698 || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE))) {
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4699 /* 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
4700 s->no_rounding = get_bits1(gb);
63
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
4701 } else {
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
4702 s->no_rounding = 0;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4703 }
253
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
4704 //FIXME reduced res stuff
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
4705
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
4706 if (s->shape != RECT_SHAPE) {
63
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
4707 if (s->vol_sprite_usage != 1 || s->pict_type != I_TYPE) {
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
4708 int width, height, hor_spat_ref, ver_spat_ref;
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
4709
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4710 width = get_bits(gb, 13);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4711 skip_bits1(gb); /* marker */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4712 height = get_bits(gb, 13);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4713 skip_bits1(gb); /* marker */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4714 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
4715 skip_bits1(gb); /* marker */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4716 ver_spat_ref = get_bits(gb, 13); /* ver_spat_ref */
63
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
4717 }
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4718 skip_bits1(gb); /* change_CR_disable */
63
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
4719
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4720 if (get_bits1(gb) != 0) {
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4721 skip_bits(gb, 8); /* constant_alpha_value */
63
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
4722 }
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
4723 }
253
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
4724 //FIXME complexity estimation stuff
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
4725
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
4726 if (s->shape != BIN_ONLY_SHAPE) {
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
4727 int t;
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4728 t=get_bits(gb, 3); /* intra dc VLC threshold */
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
4729 //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
4730 if(!s->progressive_sequence){
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4731 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
4732 s->alternate_scan= get_bits1(gb);
661
a0901e38c564 fixing interlaced mpeg4 decoding
michaelni
parents: 660
diff changeset
4733 }else
a0901e38c564 fixing interlaced mpeg4 decoding
michaelni
parents: 660
diff changeset
4734 s->alternate_scan= 0;
253
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
4735 }
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
4736
718
16dab8296293 fixing custom quantizer matrix decoding
michaelni
parents: 706
diff changeset
4737 if(s->alternate_scan){
16dab8296293 fixing custom quantizer matrix decoding
michaelni
parents: 706
diff changeset
4738 ff_init_scantable(s, &s->inter_scantable , ff_alternate_vertical_scan);
16dab8296293 fixing custom quantizer matrix decoding
michaelni
parents: 706
diff changeset
4739 ff_init_scantable(s, &s->intra_scantable , ff_alternate_vertical_scan);
16dab8296293 fixing custom quantizer matrix decoding
michaelni
parents: 706
diff changeset
4740 ff_init_scantable(s, &s->intra_h_scantable, ff_alternate_vertical_scan);
16dab8296293 fixing custom quantizer matrix decoding
michaelni
parents: 706
diff changeset
4741 ff_init_scantable(s, &s->intra_v_scantable, ff_alternate_vertical_scan);
16dab8296293 fixing custom quantizer matrix decoding
michaelni
parents: 706
diff changeset
4742 } else{
16dab8296293 fixing custom quantizer matrix decoding
michaelni
parents: 706
diff changeset
4743 ff_init_scantable(s, &s->inter_scantable , ff_zigzag_direct);
16dab8296293 fixing custom quantizer matrix decoding
michaelni
parents: 706
diff changeset
4744 ff_init_scantable(s, &s->intra_scantable , ff_zigzag_direct);
16dab8296293 fixing custom quantizer matrix decoding
michaelni
parents: 706
diff changeset
4745 ff_init_scantable(s, &s->intra_h_scantable, ff_alternate_horizontal_scan);
16dab8296293 fixing custom quantizer matrix decoding
michaelni
parents: 706
diff changeset
4746 ff_init_scantable(s, &s->intra_v_scantable, ff_alternate_vertical_scan);
16dab8296293 fixing custom quantizer matrix decoding
michaelni
parents: 706
diff changeset
4747 }
16dab8296293 fixing custom quantizer matrix decoding
michaelni
parents: 706
diff changeset
4748
253
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
4749 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
4750 mpeg4_decode_sprite_trajectory(s);
253
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
4751 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
4752 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
4753 }
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
4754
253
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
4755 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
4756 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
4757 if(s->qscale==0){
28c5c62b1c4c support decoding (with mplayer) of 3 .mp4 files from mphq
michaelni
parents: 263
diff changeset
4758 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
4759 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
4760 }
63
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
4761
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
4762 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
4763 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
4764 if(s->f_code==0){
28c5c62b1c4c support decoding (with mplayer) of 3 .mp4 files from mphq
michaelni
parents: 263
diff changeset
4765 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
4766 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
4767 }
582
5132a4ee50cd different edge positions fixed with edge emu / dr1
michaelni
parents: 575
diff changeset
4768 }else
5132a4ee50cd different edge positions fixed with edge emu / dr1
michaelni
parents: 575
diff changeset
4769 s->f_code=1;
5132a4ee50cd different edge positions fixed with edge emu / dr1
michaelni
parents: 575
diff changeset
4770
253
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
4771 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
4772 s->b_code = get_bits(gb, 3);
582
5132a4ee50cd different edge positions fixed with edge emu / dr1
michaelni
parents: 575
diff changeset
4773 }else
5132a4ee50cd different edge positions fixed with edge emu / dr1
michaelni
parents: 575
diff changeset
4774 s->b_code=1;
906
bbe0c99231a7 specific debug output support
michaelni
parents: 905
diff changeset
4775
bbe0c99231a7 specific debug output support
michaelni
parents: 905
diff changeset
4776 if(s->avctx->debug&FF_DEBUG_PICT_INFO){
930
6bcb214d6a17 more debug output
michaelni
parents: 923
diff changeset
4777 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
4778 s->qscale, s->f_code, s->b_code,
bbe0c99231a7 specific debug output support
michaelni
parents: 905
diff changeset
4779 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
4780 gb->size_in_bits,s->progressive_sequence, s->alternate_scan, s->top_field_first,
930
6bcb214d6a17 more debug output
michaelni
parents: 923
diff changeset
4781 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
4782 s->sprite_warping_accuracy);
bbe0c99231a7 specific debug output support
michaelni
parents: 905
diff changeset
4783 }
bbe0c99231a7 specific debug output support
michaelni
parents: 905
diff changeset
4784
253
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
4785 if(!s->scalability){
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
4786 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
4787 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
4788 }
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
4789 }else{
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
4790 if(s->enhancement_type){
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4791 int load_backward_shape= get_bits1(gb);
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
4792 if(load_backward_shape){
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
4793 printf("load backward shape isnt supported\n");
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
4794 }
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
4795 }
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4796 skip_bits(gb, 2); //ref_select_code
63
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
4797 }
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
4798 }
346
c2f789fe4945 detecting xvid/divx4/opendivx and set low_delay flag
michaelni
parents: 344
diff changeset
4799 /* 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
4800 // 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
4801 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
4802 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
4803 s->low_delay=1;
c2f789fe4945 detecting xvid/divx4/opendivx and set low_delay flag
michaelni
parents: 344
diff changeset
4804 }
c2f789fe4945 detecting xvid/divx4/opendivx and set low_delay flag
michaelni
parents: 344
diff changeset
4805
255
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
4806 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
4807
498
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
4808 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
4809 s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
4810
1137
7fb0b38ab5a3 cleaner & more flexible edge bug workaround
michaelni
parents: 1133
diff changeset
4811 if(!(s->workaround_bugs&FF_BUG_EDGE)){
582
5132a4ee50cd different edge positions fixed with edge emu / dr1
michaelni
parents: 575
diff changeset
4812 s->h_edge_pos= s->width;
5132a4ee50cd different edge positions fixed with edge emu / dr1
michaelni
parents: 575
diff changeset
4813 s->v_edge_pos= s->height;
5132a4ee50cd different edge positions fixed with edge emu / dr1
michaelni
parents: 575
diff changeset
4814 }
63
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
4815 return 0;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4816 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
4817
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4818 /**
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4819 * decode mpeg4 headers
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4820 * @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
4821 * 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
4822 * 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
4823 */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4824 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
4825 {
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4826 int startcode, v;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4827
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4828 /* search next start code */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4829 align_get_bits(gb);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4830 startcode = 0xff;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4831 for(;;) {
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4832 v = get_bits(gb, 8);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4833 startcode = ((startcode << 8) | v) & 0xffffffff;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4834
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
4835 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
4836 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
4837 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
4838 return FRAME_SKIPED; //divx bug
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4839 }else
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4840 return -1; //end of stream
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4841 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4842
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4843 if((startcode&0xFFFFFF00) != 0x100)
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4844 continue; //no startcode
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4845
942
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
4846 if(s->avctx->debug&FF_DEBUG_STARTCODE){
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
4847 printf("startcode: %3X ", startcode);
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
4848 if (startcode<=0x11F) printf("Video Object Start");
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
4849 else if(startcode<=0x12F) printf("Video Object Layer Start");
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
4850 else if(startcode<=0x13F) printf("Reserved");
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
4851 else if(startcode<=0x15F) printf("FGS bp start");
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
4852 else if(startcode<=0x1AF) printf("Reserved");
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
4853 else if(startcode==0x1B0) printf("Visual Object Seq Start");
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
4854 else if(startcode==0x1B1) printf("Visual Object Seq End");
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
4855 else if(startcode==0x1B2) printf("User Data");
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
4856 else if(startcode==0x1B3) printf("Group of VOP start");
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
4857 else if(startcode==0x1B4) printf("Video Session Error");
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
4858 else if(startcode==0x1B5) printf("Visual Object Start");
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
4859 else if(startcode==0x1B6) printf("Video Object Plane start");
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
4860 else if(startcode==0x1B7) printf("slice start");
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
4861 else if(startcode==0x1B8) printf("extension start");
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
4862 else if(startcode==0x1B9) printf("fgs start");
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
4863 else if(startcode==0x1BA) printf("FBA Object start");
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
4864 else if(startcode==0x1BB) printf("FBA Object Plane start");
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
4865 else if(startcode==0x1BC) printf("Mesh Object start");
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
4866 else if(startcode==0x1BD) printf("Mesh Object Plane start");
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
4867 else if(startcode==0x1BE) printf("Still Textutre Object start");
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
4868 else if(startcode==0x1BF) printf("Textutre Spatial Layer start");
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
4869 else if(startcode==0x1C0) printf("Textutre SNR Layer start");
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
4870 else if(startcode==0x1C1) printf("Textutre Tile start");
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
4871 else if(startcode==0x1C2) printf("Textutre Shape Layer start");
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
4872 else if(startcode==0x1C3) printf("stuffing start");
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
4873 else if(startcode<=0x1C5) printf("reserved");
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
4874 else if(startcode<=0x1FF) printf("System start");
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
4875 printf(" at %d\n", get_bits_count(gb));
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
4876 }
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
4877
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4878 switch(startcode){
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4879 case 0x120:
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4880 decode_vol_header(s, gb);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4881 break;
942
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
4882 case USER_DATA_STARTCODE:
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4883 decode_user_data(s, gb);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4884 break;
942
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
4885 case GOP_STARTCODE:
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
4886 mpeg4_decode_gop_header(s, gb);
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
4887 break;
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
4888 case VOP_STARTCODE:
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4889 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
4890 default:
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4891 break;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4892 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4893
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4894 align_get_bits(gb);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4895 startcode = 0xff;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4896 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4897 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
4898
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4899 /* don't understand why they choose a different header ! */
986e461dc072 Initial revision
glantau
parents:
diff changeset
4900 int intel_h263_decode_picture_header(MpegEncContext *s)
986e461dc072 Initial revision
glantau
parents:
diff changeset
4901 {
986e461dc072 Initial revision
glantau
parents:
diff changeset
4902 int format;
986e461dc072 Initial revision
glantau
parents:
diff changeset
4903
986e461dc072 Initial revision
glantau
parents:
diff changeset
4904 /* picture header */
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4905 if (get_bits(&s->gb, 22) != 0x20) {
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4906 fprintf(stderr, "Bad picture start code\n");
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4907 return -1;
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4908 }
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4909 s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4910
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4911 if (get_bits1(&s->gb) != 1) {
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4912 fprintf(stderr, "Bad marker\n");
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4913 return -1; /* marker */
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4914 }
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4915 if (get_bits1(&s->gb) != 0) {
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4916 fprintf(stderr, "Bad H263 id\n");
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4917 return -1; /* h263 id */
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4918 }
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
4919 skip_bits1(&s->gb); /* split screen off */
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
4920 skip_bits1(&s->gb); /* camera off */
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
4921 skip_bits1(&s->gb); /* freeze picture release off */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4922
986e461dc072 Initial revision
glantau
parents:
diff changeset
4923 format = get_bits(&s->gb, 3);
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4924 if (format != 7) {
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4925 fprintf(stderr, "Intel H263 free format not supported\n");
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4926 return -1;
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4927 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4928 s->h263_plus = 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
4929
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
4930 s->pict_type = I_TYPE + get_bits1(&s->gb);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4931
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
4932 s->unrestricted_mv = get_bits1(&s->gb);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4933 s->h263_long_vectors = s->unrestricted_mv;
986e461dc072 Initial revision
glantau
parents:
diff changeset
4934
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4935 if (get_bits1(&s->gb) != 0) {
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4936 fprintf(stderr, "SAC not supported\n");
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4937 return -1; /* SAC: off */
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4938 }
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4939 if (get_bits1(&s->gb) != 0) {
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4940 fprintf(stderr, "Advanced Prediction Mode not supported\n");
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4941 return -1; /* advanced prediction mode: off */
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4942 }
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4943 if (get_bits1(&s->gb) != 0) {
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4944 fprintf(stderr, "PB frame mode no supported\n");
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4945 return -1; /* PB frame mode */
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4946 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4947
986e461dc072 Initial revision
glantau
parents:
diff changeset
4948 /* skip unknown header garbage */
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
4949 skip_bits(&s->gb, 41);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4950
986e461dc072 Initial revision
glantau
parents:
diff changeset
4951 s->qscale = get_bits(&s->gb, 5);
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
4952 skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4953
986e461dc072 Initial revision
glantau
parents:
diff changeset
4954 /* PEI */
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
4955 while (get_bits1(&s->gb) != 0) {
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
4956 skip_bits(&s->gb, 8);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4957 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
4958 s->f_code = 1;
770
d1770a34e4f6 segfault fix patch by (Juergen Keil <jk at tools dot de>)
michaelni
parents: 766
diff changeset
4959
d1770a34e4f6 segfault fix patch by (Juergen Keil <jk at tools dot de>)
michaelni
parents: 766
diff changeset
4960 s->y_dc_scale_table=
d1770a34e4f6 segfault fix patch by (Juergen Keil <jk at tools dot de>)
michaelni
parents: 766
diff changeset
4961 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
4962
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4963 return 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
4964 }
144
cb5dabd00ba2 - Bug fix on inter MCBPC table for inter+q.
pulento
parents: 110
diff changeset
4965