Mercurial > libavcodec.hg
annotate h263.c @ 1483:8e7d8112de29 libavcodec
100l
author | michaelni |
---|---|
date | Sat, 27 Sep 2003 00:01:46 +0000 |
parents | b372ecde32a8 |
children | 0355f2b3519a |
rev | line source |
---|---|
0 | 1 /* |
2 * H263/MPEG4 backend for ffmpeg encoder and decoder | |
429 | 3 * Copyright (c) 2000,2001 Fabrice Bellard. |
78 | 4 * H263+ support. |
0 | 5 * Copyright (c) 2001 Juan J. Sierralta P. |
6 * | |
429 | 7 * This library is free software; you can redistribute it and/or |
8 * modify it under the terms of the GNU Lesser General Public | |
9 * License as published by the Free Software Foundation; either | |
10 * version 2 of the License, or (at your option) any later version. | |
0 | 11 * |
429 | 12 * This library is distributed in the hope that it will be useful, |
0 | 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of |
429 | 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
15 * Lesser General Public License for more details. | |
0 | 16 * |
429 | 17 * You should have received a copy of the GNU Lesser General Public |
18 * License along with this library; if not, write to the Free Software | |
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 | 24 */ |
1034 | 25 |
26 /** | |
27 * @file h263.c | |
1106 | 28 * h263/mpeg4 codec. |
1034 | 29 */ |
355 | 30 |
31 //#define DEBUG | |
0 | 32 #include "common.h" |
33 #include "dsputil.h" | |
34 #include "avcodec.h" | |
35 #include "mpegvideo.h" | |
36 #include "h263data.h" | |
37 #include "mpeg4data.h" | |
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 |
544 | 42 #define INTRA_MCBPC_VLC_BITS 6 |
1482 | 43 #define INTER_MCBPC_VLC_BITS 7 |
544 | 44 #define CBPY_VLC_BITS 6 |
45 #define MV_VLC_BITS 9 | |
46 #define DC_VLC_BITS 9 | |
47 #define SPRITE_TRAJ_VLC_BITS 6 | |
48 #define MB_TYPE_B_VLC_BITS 4 | |
49 #define TEX_VLC_BITS 9 | |
50 | |
815
78accc54493b
put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents:
770
diff
changeset
|
51 #ifdef CONFIG_ENCODERS |
0 | 52 static void h263_encode_block(MpegEncContext * s, DCTELEM * block, |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
53 int n); |
324 | 54 static void h263_encode_motion(MpegEncContext * s, int val, int fcode); |
78 | 55 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
|
56 static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
57 int n, int dc, uint8_t *scan_table, |
453 | 58 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
|
59 #endif |
78accc54493b
put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents:
770
diff
changeset
|
60 |
262 | 61 static int h263_decode_motion(MpegEncContext * s, int pred, int fcode); |
78 | 62 static int h263p_decode_umotion(MpegEncContext * s, int pred); |
0 | 63 static int h263_decode_block(MpegEncContext * s, DCTELEM * block, |
64 int n, int coded); | |
453 | 65 static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr); |
66 static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block, | |
1132 | 67 int n, int coded, int intra, int rvlc); |
1064 | 68 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
|
69 #ifdef CONFIG_ENCODERS |
1008 | 70 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
|
71 int dir); |
1424 | 72 static void mpeg4_encode_visual_object_header(MpegEncContext * s); |
73 static void mpeg4_encode_vol_header(MpegEncContext * s, int vo_number, int vol_number); | |
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
|
74 #endif //CONFIG_ENCODERS |
290 | 75 static void mpeg4_decode_sprite_trajectory(MpegEncContext * s); |
1064 | 76 static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, uint16_t **dc_val_ptr, int *dir_ptr); |
77 | |
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 #ifdef CONFIG_ENCODERS |
1064 | 79 static uint8_t uni_DCtab_lum_len[512]; |
80 static uint8_t uni_DCtab_chrom_len[512]; | |
81 static uint16_t uni_DCtab_lum_bits[512]; | |
82 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
|
83 |
1162 | 84 static uint8_t (*mv_penalty)[MAX_MV*2+1]= NULL; |
1064 | 85 static uint8_t fcode_tab[MAX_MV*2+1]; |
86 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
|
87 |
945 | 88 static uint32_t uni_mpeg4_intra_rl_bits[64*64*2*2]; |
89 static uint8_t uni_mpeg4_intra_rl_len [64*64*2*2]; | |
90 static uint32_t uni_mpeg4_inter_rl_bits[64*64*2*2]; | |
91 static uint8_t uni_mpeg4_inter_rl_len [64*64*2*2]; | |
92 //#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
|
93 //#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run) + (level)*64) |
945 | 94 #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
|
95 |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
96 /* 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
|
97 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
|
98 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
|
99 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
|
100 |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
101 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
|
102 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
|
103 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
|
104 */ |
815
78accc54493b
put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents:
770
diff
changeset
|
105 #endif |
78accc54493b
put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents:
770
diff
changeset
|
106 |
1271
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
107 #if 0 //3IV1 is quite rare and tis slows things down a tiny bit |
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
108 #define IS_3IV1 s->avctx->codec_tag == ff_get_fourcc("3IV1") |
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
109 #else |
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
110 #define IS_3IV1 0 |
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
111 #endif |
293 | 112 |
0 | 113 int h263_get_picture_format(int width, int height) |
114 { | |
115 int format; | |
116 | |
117 if (width == 128 && height == 96) | |
355 | 118 format = 1; |
0 | 119 else if (width == 176 && height == 144) |
355 | 120 format = 2; |
0 | 121 else if (width == 352 && height == 288) |
355 | 122 format = 3; |
0 | 123 else if (width == 704 && height == 576) |
355 | 124 format = 4; |
0 | 125 else if (width == 1408 && height == 1152) |
355 | 126 format = 5; |
0 | 127 else |
128 format = 7; | |
129 return format; | |
130 } | |
131 | |
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
|
132 #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
|
133 |
887 | 134 static void float_aspect_to_info(MpegEncContext * s, float aspect){ |
135 int i; | |
136 | |
137 aspect*= s->height/(double)s->width; | |
138 //printf("%f\n", aspect); | |
880 | 139 |
887 | 140 if(aspect==0) aspect= 1.0; |
141 | |
880 | 142 ff_float2fraction(&s->aspected_width, &s->aspected_height, aspect, 255); |
887 | 143 |
144 //printf("%d %d\n", s->aspected_width, s->aspected_height); | |
145 for(i=1; i<6; i++){ | |
146 if(s->aspected_width == pixel_aspect[i][0] && s->aspected_height== pixel_aspect[i][1]){ | |
147 s->aspect_ratio_info=i; | |
148 return; | |
149 } | |
150 } | |
880 | 151 |
887 | 152 s->aspect_ratio_info= FF_ASPECT_EXTENDED; |
880 | 153 } |
154 | |
1354 | 155 void ff_flv_encode_picture_header(MpegEncContext * s, int picture_number) |
0 | 156 { |
1354 | 157 int format; |
158 | |
159 align_put_bits(&s->pb); | |
160 | |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
161 put_bits(&s->pb, 17, 1); |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
162 put_bits(&s->pb, 5, (s->h263_flv-1)); /* 0: h263 escape codes 1: 11-bit escape codes */ |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
163 put_bits(&s->pb, 8, (((int64_t)s->picture_number * 30 * s->avctx->frame_rate_base) / |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
164 s->avctx->frame_rate) & 0xff); /* TemporalReference */ |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
165 if (s->width == 352 && s->height == 288) |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
166 format = 2; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
167 else if (s->width == 176 && s->height == 144) |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
168 format = 3; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
169 else if (s->width == 128 && s->height == 96) |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
170 format = 4; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
171 else if (s->width == 320 && s->height == 240) |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
172 format = 5; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
173 else if (s->width == 160 && s->height == 120) |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
174 format = 6; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
175 else if (s->width <= 255 && s->height <= 255) |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
176 format = 0; /* use 1 byte width & height */ |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
177 else |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
178 format = 1; /* use 2 bytes width & height */ |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
179 put_bits(&s->pb, 3, format); /* PictureSize */ |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
180 if (format == 0) { |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
181 put_bits(&s->pb, 8, s->width); |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
182 put_bits(&s->pb, 8, s->height); |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
183 } else if (format == 1) { |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
184 put_bits(&s->pb, 16, s->width); |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
185 put_bits(&s->pb, 16, s->height); |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
186 } |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
187 put_bits(&s->pb, 2, s->pict_type == P_TYPE); /* PictureType */ |
1390
39d07c0263de
patch for flv deblocking by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1389
diff
changeset
|
188 put_bits(&s->pb, 1, 1); /* DeblockingFlag: on */ |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
189 put_bits(&s->pb, 5, s->qscale); /* Quantizer */ |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
190 put_bits(&s->pb, 1, 0); /* ExtraInformation */ |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
191 |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
192 if(s->h263_aic){ |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
193 s->y_dc_scale_table= |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
194 s->c_dc_scale_table= h263_aic_dc_scale_table; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
195 }else{ |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
196 s->y_dc_scale_table= |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
197 s->c_dc_scale_table= ff_mpeg1_dc_scale_table; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
198 } |
1354 | 199 } |
200 | |
201 void h263_encode_picture_header(MpegEncContext * s, int picture_number) | |
202 { | |
203 int format; | |
204 | |
205 align_put_bits(&s->pb); | |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
206 |
231 | 207 /* 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
|
208 s->ptr_lastgob = pbBufPtr(&s->pb); |
231 | 209 s->gob_number = 0; |
210 | |
211 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
|
212 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
|
213 s->avctx->frame_rate) & 0xff); |
0 | 214 |
215 put_bits(&s->pb, 1, 1); /* marker */ | |
216 put_bits(&s->pb, 1, 0); /* h263 id */ | |
217 put_bits(&s->pb, 1, 0); /* split screen off */ | |
218 put_bits(&s->pb, 1, 0); /* camera off */ | |
219 put_bits(&s->pb, 1, 0); /* freeze picture release off */ | |
78 | 220 |
221 format = h263_get_picture_format(s->width, s->height); | |
0 | 222 if (!s->h263_plus) { |
223 /* H.263v1 */ | |
224 put_bits(&s->pb, 3, format); | |
225 put_bits(&s->pb, 1, (s->pict_type == P_TYPE)); | |
226 /* By now UMV IS DISABLED ON H.263v1, since the restrictions | |
227 of H.263v1 UMV implies to check the predicted MV after | |
228 calculation of the current MB to see if we're on the limits */ | |
229 put_bits(&s->pb, 1, 0); /* unrestricted motion vector: off */ | |
230 put_bits(&s->pb, 1, 0); /* SAC: off */ | |
231 put_bits(&s->pb, 1, 0); /* advanced prediction mode: off */ | |
232 put_bits(&s->pb, 1, 0); /* not PB frame */ | |
233 put_bits(&s->pb, 5, s->qscale); | |
234 put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */ | |
235 } else { | |
236 /* H.263v2 */ | |
237 /* H.263 Plus PTYPE */ | |
238 put_bits(&s->pb, 3, 7); | |
239 put_bits(&s->pb,3,1); /* Update Full Extended PTYPE */ | |
78 | 240 if (format == 7) |
241 put_bits(&s->pb,3,6); /* Custom Source Format */ | |
242 else | |
243 put_bits(&s->pb, 3, format); | |
244 | |
0 | 245 put_bits(&s->pb,1,0); /* Custom PCF: off */ |
1089 | 246 s->umvplus = s->unrestricted_mv; |
79
82e579c37bc3
Moved some H.263+ variables to MpegEncContext to be thread-safe.
pulento
parents:
78
diff
changeset
|
247 put_bits(&s->pb, 1, s->umvplus); /* Unrestricted Motion Vector */ |
0 | 248 put_bits(&s->pb,1,0); /* SAC: off */ |
249 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
|
250 put_bits(&s->pb,1,s->h263_aic); /* Advanced Intra Coding */ |
0 | 251 put_bits(&s->pb,1,0); /* Deblocking Filter: off */ |
252 put_bits(&s->pb,1,0); /* Slice Structured: off */ | |
253 put_bits(&s->pb,1,0); /* Reference Picture Selection: off */ | |
254 put_bits(&s->pb,1,0); /* Independent Segment Decoding: off */ | |
255 put_bits(&s->pb,1,0); /* Alternative Inter VLC: off */ | |
256 put_bits(&s->pb,1,0); /* Modified Quantization: off */ | |
257 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */ | |
258 put_bits(&s->pb,3,0); /* Reserved */ | |
259 | |
260 put_bits(&s->pb, 3, s->pict_type == P_TYPE); | |
261 | |
262 put_bits(&s->pb,1,0); /* Reference Picture Resampling: off */ | |
263 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
|
264 put_bits(&s->pb,1,s->no_rounding); /* Rounding Type */ |
0 | 265 put_bits(&s->pb,2,0); /* Reserved */ |
266 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */ | |
267 | |
268 /* This should be here if PLUSPTYPE */ | |
269 put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */ | |
270 | |
78 | 271 if (format == 7) { |
272 /* Custom Picture Format (CPFMT) */ | |
887 | 273 float_aspect_to_info(s, s->avctx->aspect_ratio); |
880 | 274 |
275 put_bits(&s->pb,4,s->aspect_ratio_info); | |
78 | 276 put_bits(&s->pb,9,(s->width >> 2) - 1); |
277 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */ | |
278 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
|
279 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
|
280 { |
b4bddbde44f3
aspect (ext. par too) support for h263 and mpeg4 (inc. build becouse of new vars)
al3x
parents:
667
diff
changeset
|
281 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
|
282 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
|
283 } |
78 | 284 } |
285 | |
0 | 286 /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */ |
79
82e579c37bc3
Moved some H.263+ variables to MpegEncContext to be thread-safe.
pulento
parents:
78
diff
changeset
|
287 if (s->umvplus) |
1089 | 288 // put_bits(&s->pb,1,1); /* Limited according tables of Annex D */ |
289 put_bits(&s->pb,2,1); /* unlimited */ | |
290 | |
0 | 291 put_bits(&s->pb, 5, s->qscale); |
292 } | |
293 | |
294 put_bits(&s->pb, 1, 0); /* no PEI */ | |
498 | 295 |
296 if(s->h263_aic){ | |
297 s->y_dc_scale_table= | |
298 s->c_dc_scale_table= h263_aic_dc_scale_table; | |
299 }else{ | |
300 s->y_dc_scale_table= | |
301 s->c_dc_scale_table= ff_mpeg1_dc_scale_table; | |
302 } | |
0 | 303 } |
304 | |
766 | 305 /** |
306 * Encodes a group of blocks header. | |
307 */ | |
162 | 308 int h263_encode_gob_header(MpegEncContext * s, int mb_line) |
309 { | |
310 align_put_bits(&s->pb); | |
231 | 311 flush_put_bits(&s->pb); |
312 /* Call the RTP callback to send the last GOB */ | |
313 if (s->rtp_callback) { | |
766 | 314 int pdif = pbBufPtr(&s->pb) - s->ptr_lastgob; |
231 | 315 s->rtp_callback(s->ptr_lastgob, pdif, s->gob_number); |
316 } | |
162 | 317 put_bits(&s->pb, 17, 1); /* GBSC */ |
231 | 318 s->gob_number = mb_line / s->gob_index; |
162 | 319 put_bits(&s->pb, 5, s->gob_number); /* GN */ |
231 | 320 put_bits(&s->pb, 2, s->pict_type == I_TYPE); /* GFID */ |
162 | 321 put_bits(&s->pb, 5, s->qscale); /* GQUANT */ |
231 | 322 //fprintf(stderr,"\nGOB: %2d size: %d", s->gob_number - 1, pdif); |
766 | 323 return 0; |
162 | 324 } |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
325 |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
326 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
|
327 { |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
328 int score0=0, score1=0; |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
329 int i, n; |
903 | 330 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
|
331 |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
332 for(n=0; n<6; n++){ |
1064 | 333 int16_t *ac_val, *ac_val1; |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
334 |
266 | 335 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
|
336 ac_val1= ac_val; |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
337 if(dir[n]){ |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
338 const int xy= s->mb_x + s->mb_y*s->mb_stride - s->mb_stride; |
692
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
339 /* top prediction */ |
266 | 340 ac_val-= s->block_wrap[n]*16; |
903 | 341 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
|
342 /* same qscale */ |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
343 for(i=1; i<8; i++){ |
1092 | 344 const int level= block[n][s->dsp.idct_permutation[i ]]; |
692
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
345 score0+= ABS(level); |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
346 score1+= ABS(level - ac_val[i+8]); |
1092 | 347 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
|
348 ac_val1[i+8]= level; |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
349 } |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
350 }else{ |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
351 /* different qscale, we must rescale */ |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
352 for(i=1; i<8; i++){ |
1092 | 353 const int level= block[n][s->dsp.idct_permutation[i ]]; |
692
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
354 score0+= ABS(level); |
903 | 355 score1+= ABS(level - ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale)); |
1092 | 356 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
|
357 ac_val1[i+8]= level; |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
358 } |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
359 } |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
360 }else{ |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
361 const int xy= s->mb_x-1 + s->mb_y*s->mb_stride; |
692
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
362 /* left prediction */ |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
363 ac_val-= 16; |
903 | 364 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
|
365 /* same qscale */ |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
366 for(i=1; i<8; i++){ |
1092 | 367 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
|
368 score0+= ABS(level); |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
369 score1+= ABS(level - ac_val[i]); |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
370 ac_val1[i ]= level; |
1092 | 371 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
|
372 } |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
373 }else{ |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
374 /* different qscale, we must rescale */ |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
375 for(i=1; i<8; i++){ |
1092 | 376 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
|
377 score0+= ABS(level); |
903 | 378 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
|
379 ac_val1[i ]= level; |
1092 | 380 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
|
381 } |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
382 } |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
383 } |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
384 } |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
385 |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
386 return score0 > score1 ? 1 : 0; |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
387 } |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
388 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
389 /** |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
390 * 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
|
391 */ |
695 | 392 void ff_clean_h263_qscales(MpegEncContext *s){ |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
393 int i; |
903 | 394 int8_t * const qscale_table= s->current_picture.qscale_table; |
690
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++){ |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
397 if(qscale_table[ s->mb_index2xy[i] ] - qscale_table[ s->mb_index2xy[i-1] ] >2) |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
398 qscale_table[ s->mb_index2xy[i] ]= qscale_table[ s->mb_index2xy[i-1] ]+2; |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
399 } |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
400 for(i=s->mb_num-2; i>=0; i--){ |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
401 if(qscale_table[ s->mb_index2xy[i] ] - qscale_table[ s->mb_index2xy[i+1] ] >2) |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
402 qscale_table[ s->mb_index2xy[i] ]= qscale_table[ s->mb_index2xy[i+1] ]+2; |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
403 } |
695 | 404 } |
405 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
406 /** |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
407 * 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
|
408 */ |
695 | 409 void ff_clean_mpeg4_qscales(MpegEncContext *s){ |
410 int i; | |
903 | 411 int8_t * const qscale_table= s->current_picture.qscale_table; |
412 | |
695 | 413 ff_clean_h263_qscales(s); |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
414 |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
415 for(i=1; i<s->mb_num; i++){ |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
416 int mb_xy= s->mb_index2xy[i]; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
417 |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
418 if(qscale_table[mb_xy] != qscale_table[s->mb_index2xy[i-1]] && (s->mb_type[mb_xy]&MB_TYPE_INTER4V)){ |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
419 s->mb_type[mb_xy]&= ~MB_TYPE_INTER4V; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
420 s->mb_type[mb_xy]|= MB_TYPE_INTER; |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
421 } |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
422 } |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
423 |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
424 if(s->pict_type== B_TYPE){ |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
425 int odd=0; |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
426 /* 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
|
427 for the actual adaptive quantization */ |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
428 |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
429 for(i=0; i<s->mb_num; i++){ |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
430 int mb_xy= s->mb_index2xy[i]; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
431 odd += qscale_table[mb_xy]&1; |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
432 } |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
433 |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
434 if(2*odd > s->mb_num) odd=1; |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
435 else odd=0; |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
436 |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
437 for(i=0; i<s->mb_num; i++){ |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
438 int mb_xy= s->mb_index2xy[i]; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
439 if((qscale_table[mb_xy]&1) != odd) |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
440 qscale_table[mb_xy]++; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
441 if(qscale_table[mb_xy] > 31) |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
442 qscale_table[mb_xy]= 31; |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
443 } |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
444 |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
445 for(i=1; i<s->mb_num; i++){ |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
446 int mb_xy= s->mb_index2xy[i]; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
447 if(qscale_table[mb_xy] != qscale_table[s->mb_index2xy[i-1]] && (s->mb_type[mb_xy]&MB_TYPE_DIRECT)){ |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
448 s->mb_type[mb_xy]&= ~MB_TYPE_DIRECT; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
449 s->mb_type[mb_xy]|= MB_TYPE_BIDIR; |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
450 } |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
451 } |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
452 } |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
453 } |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
454 |
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
|
455 #endif //CONFIG_ENCODERS |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
456 /** |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
457 * |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
458 * @return the mb_type |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
459 */ |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
460 int ff_mpeg4_set_direct_mv(MpegEncContext *s, int mx, int my){ |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
461 const int mb_index= s->mb_x + s->mb_y*s->mb_stride; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
462 const int colocated_mb_type= s->next_picture.mb_type[mb_index]; //FIXME or next? |
936 | 463 int xy= s->block_index[0]; |
464 uint16_t time_pp= s->pp_time; | |
465 uint16_t time_pb= s->pb_time; | |
466 int i; | |
1053
f07fd48c23d4
direct blocksize in bframes fix (might fix qpel+bframe bug)
michaelni
parents:
1042
diff
changeset
|
467 |
936 | 468 //FIXME avoid divides |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
469 |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
470 if(IS_8X8(colocated_mb_type)){ |
936 | 471 s->mv_type = MV_TYPE_8X8; |
472 for(i=0; i<4; i++){ | |
473 xy= s->block_index[i]; | |
474 s->mv[0][i][0] = s->motion_val[xy][0]*time_pb/time_pp + mx; | |
475 s->mv[0][i][1] = s->motion_val[xy][1]*time_pb/time_pp + my; | |
476 s->mv[1][i][0] = mx ? s->mv[0][i][0] - s->motion_val[xy][0] | |
477 : s->motion_val[xy][0]*(time_pb - time_pp)/time_pp; | |
478 s->mv[1][i][1] = my ? s->mv[0][i][1] - s->motion_val[xy][1] | |
479 : s->motion_val[xy][1]*(time_pb - time_pp)/time_pp; | |
480 } | |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
481 return MB_TYPE_DIRECT2 | MB_TYPE_8x8 | MB_TYPE_L0L1; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
482 } else if(IS_INTERLACED(colocated_mb_type)){ |
936 | 483 s->mv_type = MV_TYPE_FIELD; |
484 for(i=0; i<2; i++){ | |
485 if(s->top_field_first){ | |
486 time_pp= s->pp_field_time - s->field_select_table[mb_index][i] + i; | |
487 time_pb= s->pb_field_time - s->field_select_table[mb_index][i] + i; | |
488 }else{ | |
489 time_pp= s->pp_field_time + s->field_select_table[mb_index][i] - i; | |
490 time_pb= s->pb_field_time + s->field_select_table[mb_index][i] - i; | |
491 } | |
492 s->mv[0][i][0] = s->field_mv_table[mb_index][i][0]*time_pb/time_pp + mx; | |
493 s->mv[0][i][1] = s->field_mv_table[mb_index][i][1]*time_pb/time_pp + my; | |
494 s->mv[1][i][0] = mx ? s->mv[0][i][0] - s->field_mv_table[mb_index][i][0] | |
495 : s->field_mv_table[mb_index][i][0]*(time_pb - time_pp)/time_pp; | |
496 s->mv[1][i][1] = my ? s->mv[0][i][1] - s->field_mv_table[mb_index][i][1] | |
497 : s->field_mv_table[mb_index][i][1]*(time_pb - time_pp)/time_pp; | |
498 } | |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
499 return MB_TYPE_DIRECT2 | MB_TYPE_16x8 | MB_TYPE_L0L1 | MB_TYPE_INTERLACED; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
500 }else{ |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
501 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; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
502 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; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
503 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] |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
504 : s->motion_val[xy][0]*(time_pb - time_pp)/time_pp; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
505 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] |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
506 : s->motion_val[xy][1]*(time_pb - time_pp)/time_pp; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
507 if((s->avctx->workaround_bugs & FF_BUG_DIRECT_BLOCKSIZE) || !s->quarter_sample) |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
508 s->mv_type= MV_TYPE_16X16; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
509 else |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
510 s->mv_type= MV_TYPE_8X8; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
511 return MB_TYPE_DIRECT2 | MB_TYPE_16x16 | MB_TYPE_L0L1; //Note see prev line |
936 | 512 } |
513 } | |
514 | |
1389 | 515 void ff_h263_update_motion_val(MpegEncContext * s){ |
516 const int mb_xy = s->mb_y * s->mb_stride + s->mb_x; | |
517 //FIXME a lot of thet is only needed for !low_delay | |
518 const int wrap = s->block_wrap[0]; | |
519 const int xy = s->block_index[0]; | |
520 | |
521 s->current_picture.mbskip_table[mb_xy]= s->mb_skiped; | |
522 | |
523 if(s->mv_type != MV_TYPE_8X8){ | |
524 int motion_x, motion_y; | |
525 if (s->mb_intra) { | |
526 motion_x = 0; | |
527 motion_y = 0; | |
528 } else if (s->mv_type == MV_TYPE_16X16) { | |
529 motion_x = s->mv[0][0][0]; | |
530 motion_y = s->mv[0][0][1]; | |
531 } else /*if (s->mv_type == MV_TYPE_FIELD)*/ { | |
532 int i; | |
533 motion_x = s->mv[0][0][0] + s->mv[0][1][0]; | |
534 motion_y = s->mv[0][0][1] + s->mv[0][1][1]; | |
535 motion_x = (motion_x>>1) | (motion_x&1); | |
536 for(i=0; i<2; i++){ | |
537 s->field_mv_table[mb_xy][i][0]= s->mv[0][i][0]; | |
538 s->field_mv_table[mb_xy][i][1]= s->mv[0][i][1]; | |
539 s->field_select_table[mb_xy][i]= s->field_select[0][i]; | |
540 } | |
541 } | |
542 | |
543 /* no update if 8X8 because it has been done during parsing */ | |
544 s->motion_val[xy][0] = motion_x; | |
545 s->motion_val[xy][1] = motion_y; | |
546 s->motion_val[xy + 1][0] = motion_x; | |
547 s->motion_val[xy + 1][1] = motion_y; | |
548 s->motion_val[xy + wrap][0] = motion_x; | |
549 s->motion_val[xy + wrap][1] = motion_y; | |
550 s->motion_val[xy + 1 + wrap][0] = motion_x; | |
551 s->motion_val[xy + 1 + wrap][1] = motion_y; | |
552 } | |
553 | |
554 if(s->encoding){ //FIXME encoding MUST be cleaned up | |
555 if (s->mv_type == MV_TYPE_8X8) | |
556 s->current_picture.mb_type[mb_xy]= MB_TYPE_L0 | MB_TYPE_8x8; | |
557 else | |
558 s->current_picture.mb_type[mb_xy]= MB_TYPE_L0 | MB_TYPE_16x16; | |
559 } | |
560 } | |
561 | |
815
78accc54493b
put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents:
770
diff
changeset
|
562 #ifdef CONFIG_ENCODERS |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
563 void mpeg4_encode_mb(MpegEncContext * s, |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
564 DCTELEM block[6][64], |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
565 int motion_x, int motion_y) |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
566 { |
1057 | 567 int cbpc, cbpy, pred_x, pred_y; |
453 | 568 PutBitContext * const pb2 = s->data_partitioning ? &s->pb2 : &s->pb; |
569 PutBitContext * const tex_pb = s->data_partitioning && s->pict_type!=B_TYPE ? &s->tex_pb : &s->pb; | |
570 PutBitContext * const dc_pb = s->data_partitioning && s->pict_type!=I_TYPE ? &s->pb2 : &s->pb; | |
571 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
|
572 const int dquant_code[5]= {1,0,9,2,3}; |
162 | 573 |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
574 // 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
|
575 if (!s->mb_intra) { |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
576 /* compute cbp */ |
1057 | 577 int i, cbp = 0; |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
578 for (i = 0; i < 6; i++) { |
324 | 579 if (s->block_last_index[i] >= 0) |
580 cbp |= 1 << (5 - i); | |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
581 } |
324 | 582 |
583 if(s->pict_type==B_TYPE){ | |
584 static const int mb_type_table[8]= {-1, 2, 3, 1,-1,-1,-1, 0}; /* convert from mv_dir to type */ | |
585 int mb_type= mb_type_table[s->mv_dir]; | |
586 | |
587 if(s->mb_x==0){ | |
588 s->last_mv[0][0][0]= | |
589 s->last_mv[0][0][1]= | |
590 s->last_mv[1][0][0]= | |
591 s->last_mv[1][0][1]= 0; | |
592 } | |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
593 |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
594 assert(s->dquant>=-2 && s->dquant<=2); |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
595 assert((s->dquant&1)==0); |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
596 assert(mb_type>=0); |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
597 |
324 | 598 /* nothing to do if this MB was skiped in the next P Frame */ |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
599 if(s->next_picture.mbskip_table[s->mb_y * s->mb_stride + s->mb_x]){ //FIXME avoid DCT & ... |
324 | 600 s->skip_count++; |
601 s->mv[0][0][0]= | |
602 s->mv[0][0][1]= | |
603 s->mv[1][0][0]= | |
604 s->mv[1][0][1]= 0; | |
327 | 605 s->mv_dir= MV_DIR_FORWARD; //doesnt matter |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
606 s->qscale -= s->dquant; |
903 | 607 // s->mb_skiped=1; |
608 | |
324 | 609 return; |
610 } | |
936 | 611 |
324 | 612 if ((cbp | motion_x | motion_y | mb_type) ==0) { |
613 /* direct MB with MV={0,0} */ | |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
614 assert(s->dquant==0); |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
615 |
324 | 616 put_bits(&s->pb, 1, 1); /* mb not coded modb1=1 */ |
453 | 617 |
618 if(interleaved_stats){ | |
619 s->misc_bits++; | |
620 s->last_bits++; | |
621 } | |
324 | 622 s->skip_count++; |
623 return; | |
624 } | |
903 | 625 |
324 | 626 put_bits(&s->pb, 1, 0); /* mb coded modb1=0 */ |
627 put_bits(&s->pb, 1, cbp ? 0 : 1); /* modb2 */ //FIXME merge | |
628 put_bits(&s->pb, mb_type+1, 1); // this table is so simple that we dont need it :) | |
629 if(cbp) put_bits(&s->pb, 6, cbp); | |
630 | |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
631 if(cbp && mb_type){ |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
632 if(s->dquant) |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
633 put_bits(&s->pb, 2, (s->dquant>>2)+3); |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
634 else |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
635 put_bits(&s->pb, 1, 0); |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
636 }else |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
637 s->qscale -= s->dquant; |
697 | 638 |
639 if(!s->progressive_sequence){ | |
640 if(cbp) | |
641 put_bits(&s->pb, 1, s->interlaced_dct); | |
642 if(mb_type) // not diect mode | |
643 put_bits(&s->pb, 1, 0); // no interlaced ME yet | |
644 } | |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
645 |
453 | 646 if(interleaved_stats){ |
1164 | 647 s->misc_bits+= get_bits_diff(s); |
453 | 648 } |
295 | 649 |
324 | 650 switch(mb_type) |
651 { | |
652 case 0: /* direct */ | |
653 h263_encode_motion(s, motion_x, 1); | |
654 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
|
655 s->b_count++; |
e47fa3e3f2d5
statistics for forw & back p-MBs instead of just one counter for both
michaelni
parents:
654
diff
changeset
|
656 s->f_count++; |
324 | 657 break; |
658 case 1: /* bidir */ | |
659 h263_encode_motion(s, s->mv[0][0][0] - s->last_mv[0][0][0], s->f_code); | |
660 h263_encode_motion(s, s->mv[0][0][1] - s->last_mv[0][0][1], s->f_code); | |
661 h263_encode_motion(s, s->mv[1][0][0] - s->last_mv[1][0][0], s->b_code); | |
662 h263_encode_motion(s, s->mv[1][0][1] - s->last_mv[1][0][1], s->b_code); | |
663 s->last_mv[0][0][0]= s->mv[0][0][0]; | |
664 s->last_mv[0][0][1]= s->mv[0][0][1]; | |
665 s->last_mv[1][0][0]= s->mv[1][0][0]; | |
666 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
|
667 s->b_count++; |
e47fa3e3f2d5
statistics for forw & back p-MBs instead of just one counter for both
michaelni
parents:
654
diff
changeset
|
668 s->f_count++; |
324 | 669 break; |
670 case 2: /* backward */ | |
671 h263_encode_motion(s, motion_x - s->last_mv[1][0][0], s->b_code); | |
672 h263_encode_motion(s, motion_y - s->last_mv[1][0][1], s->b_code); | |
673 s->last_mv[1][0][0]= motion_x; | |
674 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
|
675 s->b_count++; |
324 | 676 break; |
677 case 3: /* forward */ | |
678 h263_encode_motion(s, motion_x - s->last_mv[0][0][0], s->f_code); | |
679 h263_encode_motion(s, motion_y - s->last_mv[0][0][1], s->f_code); | |
680 s->last_mv[0][0][0]= motion_x; | |
681 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
|
682 s->f_count++; |
324 | 683 break; |
327 | 684 default: |
685 printf("unknown mb type\n"); | |
324 | 686 return; |
687 } | |
453 | 688 |
689 if(interleaved_stats){ | |
1164 | 690 s->mv_bits+= get_bits_diff(s); |
453 | 691 } |
295 | 692 |
324 | 693 /* encode each block */ |
694 for (i = 0; i < 6; i++) { | |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
702
diff
changeset
|
695 mpeg4_encode_block(s, block[i], i, 0, s->intra_scantable.permutated, NULL, &s->pb); |
324 | 696 } |
453 | 697 |
698 if(interleaved_stats){ | |
1164 | 699 s->p_tex_bits+= get_bits_diff(s); |
453 | 700 } |
324 | 701 }else{ /* s->pict_type==B_TYPE */ |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
702 if ((cbp | motion_x | motion_y | s->dquant) == 0 && s->mv_type==MV_TYPE_16X16) { |
331 | 703 /* check if the B frames can skip it too, as we must skip it if we skip here |
704 why didnt they just compress the skip-mb bits instead of reusing them ?! */ | |
705 if(s->max_b_frames>0){ | |
706 int i; | |
364
6b6332e7008a
segfault fix for b-frame encoding with height%16!=0
michaelni
parents:
360
diff
changeset
|
707 int x,y, offset; |
6b6332e7008a
segfault fix for b-frame encoding with height%16!=0
michaelni
parents:
360
diff
changeset
|
708 uint8_t *p_pic; |
6b6332e7008a
segfault fix for b-frame encoding with height%16!=0
michaelni
parents:
360
diff
changeset
|
709 |
6b6332e7008a
segfault fix for b-frame encoding with height%16!=0
michaelni
parents:
360
diff
changeset
|
710 x= s->mb_x*16; |
6b6332e7008a
segfault fix for b-frame encoding with height%16!=0
michaelni
parents:
360
diff
changeset
|
711 y= s->mb_y*16; |
6b6332e7008a
segfault fix for b-frame encoding with height%16!=0
michaelni
parents:
360
diff
changeset
|
712 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
|
713 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
|
714 |
6b6332e7008a
segfault fix for b-frame encoding with height%16!=0
michaelni
parents:
360
diff
changeset
|
715 offset= x + y*s->linesize; |
903 | 716 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
|
717 |
331 | 718 s->mb_skiped=1; |
719 for(i=0; i<s->max_b_frames; i++){ | |
339 | 720 uint8_t *b_pic; |
721 int diff; | |
903 | 722 Picture *pic= s->reordered_input_picture[i+1]; |
723 | |
724 if(pic==NULL || pic->pict_type!=B_TYPE) break; | |
725 | |
726 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
|
727 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
|
728 if(diff>s->qscale*70){ //FIXME check that 70 is optimal |
331 | 729 s->mb_skiped=0; |
730 break; | |
731 } | |
732 } | |
733 }else | |
734 s->mb_skiped=1; | |
735 | |
736 if(s->mb_skiped==1){ | |
737 /* skip macroblock */ | |
738 put_bits(&s->pb, 1, 1); | |
453 | 739 |
740 if(interleaved_stats){ | |
741 s->misc_bits++; | |
742 s->last_bits++; | |
743 } | |
331 | 744 s->skip_count++; |
1271
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
745 |
331 | 746 return; |
747 } | |
295 | 748 } |
364
6b6332e7008a
segfault fix for b-frame encoding with height%16!=0
michaelni
parents:
360
diff
changeset
|
749 |
324 | 750 put_bits(&s->pb, 1, 0); /* mb coded */ |
751 if(s->mv_type==MV_TYPE_16X16){ | |
752 cbpc = cbp & 3; | |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
753 if(s->dquant) cbpc+= 8; |
324 | 754 put_bits(&s->pb, |
755 inter_MCBPC_bits[cbpc], | |
756 inter_MCBPC_code[cbpc]); | |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
757 |
324 | 758 cbpy = cbp >> 2; |
759 cbpy ^= 0xf; | |
453 | 760 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
|
761 if(s->dquant) |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
762 put_bits(pb2, 2, dquant_code[s->dquant+2]); |
697 | 763 |
764 if(!s->progressive_sequence){ | |
765 if(cbp) | |
766 put_bits(pb2, 1, s->interlaced_dct); | |
767 put_bits(pb2, 1, 0); // no interlaced ME yet | |
768 } | |
324 | 769 |
453 | 770 if(interleaved_stats){ |
1164 | 771 s->misc_bits+= get_bits_diff(s); |
453 | 772 } |
324 | 773 |
774 /* motion vectors: 16x16 mode */ | |
775 h263_pred_motion(s, 0, &pred_x, &pred_y); | |
776 | |
777 h263_encode_motion(s, motion_x - pred_x, s->f_code); | |
778 h263_encode_motion(s, motion_y - pred_y, s->f_code); | |
779 }else{ | |
780 cbpc = (cbp & 3)+16; | |
781 put_bits(&s->pb, | |
782 inter_MCBPC_bits[cbpc], | |
783 inter_MCBPC_code[cbpc]); | |
784 cbpy = cbp >> 2; | |
785 cbpy ^= 0xf; | |
453 | 786 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]); |
787 | |
757 | 788 if(!s->progressive_sequence){ |
789 if(cbp) | |
790 put_bits(pb2, 1, s->interlaced_dct); | |
791 } | |
792 | |
453 | 793 if(interleaved_stats){ |
1164 | 794 s->misc_bits+= get_bits_diff(s); |
453 | 795 } |
324 | 796 |
797 for(i=0; i<4; i++){ | |
798 /* motion vectors: 8x8 mode*/ | |
799 h263_pred_motion(s, i, &pred_x, &pred_y); | |
800 | |
801 h263_encode_motion(s, s->motion_val[ s->block_index[i] ][0] - pred_x, s->f_code); | |
802 h263_encode_motion(s, s->motion_val[ s->block_index[i] ][1] - pred_y, s->f_code); | |
803 } | |
804 } | |
453 | 805 |
806 if(interleaved_stats){ | |
1164 | 807 s->mv_bits+= get_bits_diff(s); |
453 | 808 } |
324 | 809 |
810 /* encode each block */ | |
811 for (i = 0; i < 6; i++) { | |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
702
diff
changeset
|
812 mpeg4_encode_block(s, block[i], i, 0, s->intra_scantable.permutated, NULL, tex_pb); |
324 | 813 } |
453 | 814 |
815 if(interleaved_stats){ | |
1164 | 816 s->p_tex_bits+= get_bits_diff(s); |
453 | 817 } |
656
e47fa3e3f2d5
statistics for forw & back p-MBs instead of just one counter for both
michaelni
parents:
654
diff
changeset
|
818 s->f_count++; |
295 | 819 } |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
820 } else { |
324 | 821 int cbp; |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
822 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
|
823 int dir[6]; //prediction direction |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
824 int zigzag_last_index[6]; |
1064 | 825 uint8_t *scan_table[6]; |
1057 | 826 int i; |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
827 |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
828 for(i=0; i<6; i++){ |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
829 const int level= block[i][0]; |
1064 | 830 uint16_t *dc_ptr; |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
831 |
498 | 832 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
|
833 if (i < 4) { |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
834 *dc_ptr = level * s->y_dc_scale; |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
835 } else { |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
836 *dc_ptr = level * s->c_dc_scale; |
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 } |
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 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
|
841 |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
842 if(s->ac_pred){ |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
843 for(i=0; i<6; i++){ |
1064 | 844 uint8_t *st; |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
845 int last_index; |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
846 |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
847 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
|
848 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
|
849 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
|
850 |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
851 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
|
852 if(block[i][st[last_index]]) break; |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
853 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
|
854 s->block_last_index[i]= last_index; |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
855 scan_table[i]= st; |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
856 } |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
857 }else{ |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
858 for(i=0; i<6; i++) |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
702
diff
changeset
|
859 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
|
860 } |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
861 |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
862 /* compute cbp */ |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
863 cbp = 0; |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
864 for (i = 0; i < 6; i++) { |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
865 if (s->block_last_index[i] >= 1) |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
866 cbp |= 1 << (5 - i); |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
867 } |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
868 |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
869 cbpc = cbp & 3; |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
870 if (s->pict_type == I_TYPE) { |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
871 if(s->dquant) cbpc+=4; |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
872 put_bits(&s->pb, |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
873 intra_MCBPC_bits[cbpc], |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
874 intra_MCBPC_code[cbpc]); |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
875 } else { |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
876 if(s->dquant) cbpc+=8; |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
877 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
|
878 put_bits(&s->pb, |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
879 inter_MCBPC_bits[cbpc + 4], |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
880 inter_MCBPC_code[cbpc + 4]); |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
881 } |
453 | 882 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
|
883 cbpy = cbp >> 2; |
453 | 884 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
|
885 if(s->dquant) |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
886 put_bits(dc_pb, 2, dquant_code[s->dquant+2]); |
453 | 887 |
697 | 888 if(!s->progressive_sequence){ |
889 put_bits(dc_pb, 1, s->interlaced_dct); | |
890 } | |
891 | |
453 | 892 if(interleaved_stats){ |
1164 | 893 s->misc_bits+= get_bits_diff(s); |
453 | 894 } |
286 | 895 |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
896 /* encode each block */ |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
897 for (i = 0; i < 6; i++) { |
453 | 898 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
|
899 } |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
900 |
453 | 901 if(interleaved_stats){ |
1164 | 902 s->i_tex_bits+= get_bits_diff(s); |
453 | 903 } |
286 | 904 s->i_count++; |
905 | |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
906 /* 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
|
907 if(s->ac_pred){ |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
908 for(i=0; i<6; i++){ |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
909 int j; |
1064 | 910 int16_t *ac_val; |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
911 |
266 | 912 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
|
913 |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
914 if(dir[i]){ |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
915 for(j=1; j<8; j++) |
1092 | 916 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
|
917 }else{ |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
918 for(j=1; j<8; j++) |
1092 | 919 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
|
920 } |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
921 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
|
922 } |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
923 } |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
924 } |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
925 } |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
926 |
0 | 927 void h263_encode_mb(MpegEncContext * s, |
928 DCTELEM block[6][64], | |
929 int motion_x, int motion_y) | |
930 { | |
931 int cbpc, cbpy, i, cbp, pred_x, pred_y; | |
1064 | 932 int16_t pred_dc; |
933 int16_t rec_intradc[6]; | |
934 uint16_t *dc_ptr[6]; | |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
935 const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1); |
695 | 936 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
|
937 |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
938 //printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y); |
324 | 939 if (!s->mb_intra) { |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
940 /* compute cbp */ |
324 | 941 cbp = 0; |
942 for (i = 0; i < 6; i++) { | |
943 if (s->block_last_index[i] >= 0) | |
944 cbp |= 1 << (5 - i); | |
945 } | |
695 | 946 if ((cbp | motion_x | motion_y | s->dquant) == 0) { |
324 | 947 /* skip macroblock */ |
948 put_bits(&s->pb, 1, 1); | |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
949 if(interleaved_stats){ |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
950 s->misc_bits++; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
951 s->last_bits++; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
952 } |
324 | 953 return; |
954 } | |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
955 put_bits(&s->pb, 1, 0); /* mb coded */ |
324 | 956 cbpc = cbp & 3; |
695 | 957 if(s->dquant) cbpc+= 8; |
324 | 958 put_bits(&s->pb, |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
959 inter_MCBPC_bits[cbpc], |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
960 inter_MCBPC_code[cbpc]); |
324 | 961 cbpy = cbp >> 2; |
962 cbpy ^= 0xf; | |
963 put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]); | |
695 | 964 if(s->dquant) |
965 put_bits(&s->pb, 2, dquant_code[s->dquant+2]); | |
0 | 966 |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
967 if(interleaved_stats){ |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
968 s->misc_bits+= get_bits_diff(s); |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
969 } |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
970 |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
971 /* motion vectors: 16x16 mode only now */ |
324 | 972 h263_pred_motion(s, 0, &pred_x, &pred_y); |
78 | 973 |
324 | 974 if (!s->umvplus) { |
975 h263_encode_motion(s, motion_x - pred_x, s->f_code); | |
976 h263_encode_motion(s, motion_y - pred_y, s->f_code); | |
977 } | |
978 else { | |
979 h263p_encode_umotion(s, motion_x - pred_x); | |
980 h263p_encode_umotion(s, motion_y - pred_y); | |
981 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
|
982 /* To prevent Start Code emulation */ |
324 | 983 put_bits(&s->pb,1,1); |
984 } | |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
985 |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
986 if(interleaved_stats){ |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
987 s->mv_bits+= get_bits_diff(s); |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
988 } |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
989 } else { |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
990 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
|
991 |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
992 cbp = 0; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
993 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
|
994 /* Predict DC */ |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
995 if (s->h263_aic && s->mb_intra) { |
1064 | 996 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
|
997 |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
998 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
|
999 level -= pred_dc; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1000 /* Quant */ |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1001 if (level < 0) |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1002 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
|
1003 else |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1004 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
|
1005 |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1006 /* AIC can change CBP */ |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1007 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
|
1008 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
|
1009 else if (level < -127) |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1010 level = -127; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1011 else if (level > 127) |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1012 level = 127; |
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 block[i][0] = level; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1015 /* Reconstruction */ |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1016 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
|
1017 /* Oddify */ |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1018 rec_intradc[i] |= 1; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1019 //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
|
1020 // rec_intradc[i]++; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1021 /* Clipping */ |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1022 if (rec_intradc[i] < 0) |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1023 rec_intradc[i] = 0; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1024 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
|
1025 rec_intradc[i] = 2047; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1026 |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1027 /* Update AC/DC tables */ |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1028 *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
|
1029 } |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1030 /* compute cbp */ |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1031 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
|
1032 cbp |= 1 << (5 - i); |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1033 } |
0 | 1034 |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1035 cbpc = cbp & 3; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1036 if (s->pict_type == I_TYPE) { |
695 | 1037 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
|
1038 put_bits(&s->pb, |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1039 intra_MCBPC_bits[cbpc], |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1040 intra_MCBPC_code[cbpc]); |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1041 } else { |
695 | 1042 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
|
1043 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
|
1044 put_bits(&s->pb, |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1045 inter_MCBPC_bits[cbpc + 4], |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1046 inter_MCBPC_code[cbpc + 4]); |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1047 } |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1048 if (s->h263_aic) { |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1049 /* 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
|
1050 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
|
1051 } |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1052 cbpy = cbp >> 2; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1053 put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]); |
695 | 1054 if(s->dquant) |
1055 put_bits(&s->pb, 2, dquant_code[s->dquant+2]); | |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1056 |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1057 if(interleaved_stats){ |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1058 s->misc_bits+= get_bits_diff(s); |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1059 } |
0 | 1060 } |
1061 | |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1062 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
|
1063 /* encode each block */ |
1354 | 1064 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
|
1065 |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1066 /* Update INTRADC for decoding */ |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1067 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
|
1068 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
|
1069 |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1070 } |
0 | 1071 } |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1072 |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1073 if(interleaved_stats){ |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1074 if (!s->mb_intra) { |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1075 s->p_tex_bits+= get_bits_diff(s); |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1076 s->f_count++; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1077 }else{ |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1078 s->i_tex_bits+= get_bits_diff(s); |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1079 s->i_count++; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1080 } |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1081 } |
0 | 1082 } |
815
78accc54493b
put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents:
770
diff
changeset
|
1083 #endif |
0 | 1084 |
1064 | 1085 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
|
1086 { |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1087 int x, y, wrap, a, c, pred_dc, scale; |
1064 | 1088 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
|
1089 |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1090 /* find prediction */ |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1091 if (n < 4) { |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1092 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
|
1093 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
|
1094 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
|
1095 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
|
1096 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
|
1097 scale = s->y_dc_scale; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1098 } else { |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1099 x = s->mb_x + 1; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1100 y = s->mb_y + 1; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1101 wrap = s->mb_width + 2; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1102 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
|
1103 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
|
1104 scale = s->c_dc_scale; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1105 } |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1106 /* B C |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1107 * A X |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1108 */ |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1109 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
|
1110 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
|
1111 |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1112 /* No prediction outside GOB boundary */ |
453 | 1113 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
|
1114 c = 1024; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1115 pred_dc = 1024; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1116 /* just DC prediction */ |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1117 if (a != 1024 && c != 1024) |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1118 pred_dc = (a + c) >> 1; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1119 else if (a != 1024) |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1120 pred_dc = a; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1121 else |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1122 pred_dc = c; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1123 |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1124 /* we assume pred is positive */ |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1125 //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
|
1126 *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
|
1127 return pred_dc; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1128 } |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1129 |
1057 | 1130 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
|
1131 { |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1132 int x, y, wrap, a, c, pred_dc, scale, i; |
1064 | 1133 int16_t *dc_val, *ac_val, *ac_val1; |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1134 |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1135 /* find prediction */ |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1136 if (n < 4) { |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1137 x = 2 * s->mb_x + 1 + (n & 1); |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1138 y = 2 * s->mb_y + 1 + ((n & 2) >> 1); |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1139 wrap = s->mb_width * 2 + 2; |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1140 dc_val = s->dc_val[0]; |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1141 ac_val = s->ac_val[0][0]; |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1142 scale = s->y_dc_scale; |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1143 } else { |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1144 x = s->mb_x + 1; |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1145 y = s->mb_y + 1; |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1146 wrap = s->mb_width + 2; |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1147 dc_val = s->dc_val[n - 4 + 1]; |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1148 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
|
1149 scale = s->c_dc_scale; |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1150 } |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1151 |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1152 ac_val += ((y) * wrap + (x)) * 16; |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1153 ac_val1 = ac_val; |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1154 |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1155 /* B C |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1156 * A X |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1157 */ |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1158 a = dc_val[(x - 1) + (y) * wrap]; |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1159 c = dc_val[(x) + (y - 1) * wrap]; |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1160 |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1161 /* No prediction outside GOB boundary */ |
453 | 1162 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
|
1163 c = 1024; |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1164 pred_dc = 1024; |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1165 if (s->ac_pred) { |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1166 if (s->h263_aic_dir) { |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1167 /* left prediction */ |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1168 if (a != 1024) { |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1169 ac_val -= 16; |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1170 for(i=1;i<8;i++) { |
1092 | 1171 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
|
1172 } |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1173 pred_dc = a; |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1174 } |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1175 } else { |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1176 /* top prediction */ |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1177 if (c != 1024) { |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1178 ac_val -= 16 * wrap; |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1179 for(i=1;i<8;i++) { |
1092 | 1180 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
|
1181 } |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1182 pred_dc = c; |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1183 } |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1184 } |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1185 } else { |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1186 /* just DC prediction */ |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1187 if (a != 1024 && c != 1024) |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1188 pred_dc = (a + c) >> 1; |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1189 else if (a != 1024) |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1190 pred_dc = a; |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1191 else |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1192 pred_dc = c; |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1193 } |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1194 |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1195 /* we assume pred is positive */ |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1196 block[0]=block[0]*scale + pred_dc; |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1197 |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1198 if (block[0] < 0) |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1199 block[0] = 0; |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1200 else if (!(block[0] & 1)) |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1201 block[0]++; |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1202 |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1203 /* Update AC/DC tables */ |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1204 dc_val[(x) + (y) * wrap] = block[0]; |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1205 |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1206 /* left copy */ |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1207 for(i=1;i<8;i++) |
1092 | 1208 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
|
1209 /* top copy */ |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1210 for(i=1;i<8;i++) |
1092 | 1211 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
|
1212 } |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1213 |
1064 | 1214 int16_t *h263_pred_motion(MpegEncContext * s, int block, |
0 | 1215 int *px, int *py) |
1216 { | |
266 | 1217 int xy, wrap; |
1064 | 1218 int16_t *A, *B, *C, *mot_val; |
264
28c5c62b1c4c
support decoding (with mplayer) of 3 .mp4 files from mphq
michaelni
parents:
263
diff
changeset
|
1219 static const int off[4]= {2, 1, 1, -1}; |
0 | 1220 |
266 | 1221 wrap = s->block_wrap[0]; |
1222 xy = s->block_index[block]; | |
0 | 1223 |
245 | 1224 mot_val = s->motion_val[xy]; |
0 | 1225 |
453 | 1226 A = s->motion_val[xy - 1]; |
1227 /* special case for first (slice) line */ | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
1228 if (s->first_slice_line && block<3) { |
453 | 1229 // we cant just change some MVs to simulate that as we need them for the B frames (and ME) |
1230 // and if we ever support non rectangular objects than we need to do a few ifs here anyway :( | |
1231 if(block==0){ //most common case | |
1232 if(s->mb_x == s->resync_mb_x){ //rare | |
1233 *px= *py = 0; | |
1234 }else if(s->mb_x + 1 == s->resync_mb_x){ //rare | |
1235 C = s->motion_val[xy + off[block] - wrap]; | |
1236 if(s->mb_x==0){ | |
1237 *px = C[0]; | |
1238 *py = C[1]; | |
1239 }else{ | |
1240 *px = mid_pred(A[0], 0, C[0]); | |
1241 *py = mid_pred(A[1], 0, C[1]); | |
1242 } | |
1243 }else{ | |
1244 *px = A[0]; | |
1245 *py = A[1]; | |
1246 } | |
1247 }else if(block==1){ | |
1248 if(s->mb_x + 1 == s->resync_mb_x){ //rare | |
1249 C = s->motion_val[xy + off[block] - wrap]; | |
1250 *px = mid_pred(A[0], 0, C[0]); | |
1251 *py = mid_pred(A[1], 0, C[1]); | |
1252 }else{ | |
1253 *px = A[0]; | |
1254 *py = A[1]; | |
1255 } | |
1256 }else{ /* block==2*/ | |
1257 B = s->motion_val[xy - wrap]; | |
1258 C = s->motion_val[xy + off[block] - wrap]; | |
1259 if(s->mb_x == s->resync_mb_x) //rare | |
1260 A[0]=A[1]=0; | |
1261 | |
1262 *px = mid_pred(A[0], B[0], C[0]); | |
1263 *py = mid_pred(A[1], B[1], C[1]); | |
1264 } | |
0 | 1265 } else { |
264
28c5c62b1c4c
support decoding (with mplayer) of 3 .mp4 files from mphq
michaelni
parents:
263
diff
changeset
|
1266 B = s->motion_val[xy - wrap]; |
28c5c62b1c4c
support decoding (with mplayer) of 3 .mp4 files from mphq
michaelni
parents:
263
diff
changeset
|
1267 C = s->motion_val[xy + off[block] - wrap]; |
0 | 1268 *px = mid_pred(A[0], B[0], C[0]); |
1269 *py = mid_pred(A[1], B[1], C[1]); | |
1270 } | |
1271 return mot_val; | |
1272 } | |
1273 | |
815
78accc54493b
put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents:
770
diff
changeset
|
1274 #ifdef CONFIG_ENCODERS |
324 | 1275 static void h263_encode_motion(MpegEncContext * s, int val, int f_code) |
0 | 1276 { |
702 | 1277 int range, l, bit_size, sign, code, bits; |
0 | 1278 |
1279 if (val == 0) { | |
1280 /* zero vector */ | |
1281 code = 0; | |
1282 put_bits(&s->pb, mvtab[code][1], mvtab[code][0]); | |
1283 } else { | |
324 | 1284 bit_size = f_code - 1; |
0 | 1285 range = 1 << bit_size; |
1286 /* modulo encoding */ | |
1287 l = range * 32; | |
702 | 1288 #if 1 |
1289 val+= l; | |
1290 val&= 2*l-1; | |
1291 val-= l; | |
1292 sign = val>>31; | |
1293 val= (val^sign)-sign; | |
1294 sign&=1; | |
1295 #else | |
0 | 1296 if (val < -l) { |
702 | 1297 val += 2*l; |
0 | 1298 } else if (val >= l) { |
702 | 1299 val -= 2*l; |
0 | 1300 } |
702 | 1301 |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
1302 assert(val>=-l && val<l); |
0 | 1303 |
1304 if (val >= 0) { | |
1305 sign = 0; | |
1306 } else { | |
1307 val = -val; | |
1308 sign = 1; | |
1309 } | |
702 | 1310 #endif |
312 | 1311 val--; |
1312 code = (val >> bit_size) + 1; | |
1313 bits = val & (range - 1); | |
0 | 1314 |
1315 put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign); | |
1316 if (bit_size > 0) { | |
1317 put_bits(&s->pb, bit_size, bits); | |
1318 } | |
1319 } | |
718 | 1320 |
0 | 1321 } |
1322 | |
78 | 1323 /* Encode MV differences on H.263+ with Unrestricted MV mode */ |
1324 static void h263p_encode_umotion(MpegEncContext * s, int val) | |
1325 { | |
1326 short sval = 0; | |
1327 short i = 0; | |
1328 short n_bits = 0; | |
1329 short temp_val; | |
1330 int code = 0; | |
1331 int tcode; | |
1332 | |
1333 if ( val == 0) | |
1334 put_bits(&s->pb, 1, 1); | |
1335 else if (val == 1) | |
1336 put_bits(&s->pb, 3, 0); | |
1337 else if (val == -1) | |
1338 put_bits(&s->pb, 3, 2); | |
1339 else { | |
1340 | |
1341 sval = ((val < 0) ? (short)(-val):(short)val); | |
1342 temp_val = sval; | |
1343 | |
1344 while (temp_val != 0) { | |
1345 temp_val = temp_val >> 1; | |
1346 n_bits++; | |
1347 } | |
1348 | |
1349 i = n_bits - 1; | |
1350 while (i > 0) { | |
1351 tcode = (sval & (1 << (i-1))) >> (i-1); | |
1352 tcode = (tcode << 1) | 1; | |
1353 code = (code << 2) | tcode; | |
1354 i--; | |
1355 } | |
1356 code = ((code << 1) | (val < 0)) << 1; | |
1357 put_bits(&s->pb, (2*n_bits)+1, code); | |
1358 //printf("\nVal = %d\tCode = %d", sval, code); | |
1359 } | |
1360 } | |
1361 | |
277
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1362 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
|
1363 { |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1364 int f_code; |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1365 int mv; |
815
78accc54493b
put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents:
770
diff
changeset
|
1366 |
78accc54493b
put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents:
770
diff
changeset
|
1367 if(mv_penalty==NULL) |
1162 | 1368 mv_penalty= av_mallocz( sizeof(uint8_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
|
1369 |
277
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1370 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
|
1371 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
|
1372 int len; |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1373 |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1374 if(mv==0) len= mvtab[0][1]; |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1375 else{ |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1376 int val, bit_size, range, code; |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1377 |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1378 bit_size = s->f_code - 1; |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1379 range = 1 << bit_size; |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1380 |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1381 val=mv; |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1382 if (val < 0) |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1383 val = -val; |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1384 val--; |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1385 code = (val >> bit_size) + 1; |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1386 if(code<33){ |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1387 len= mvtab[code][1] + 1 + bit_size; |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1388 }else{ |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1389 len= mvtab[32][1] + 2 + bit_size; |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1390 } |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1391 } |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1392 |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1393 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
|
1394 } |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1395 } |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1396 |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1397 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
|
1398 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
|
1399 fcode_tab[mv+MAX_MV]= f_code; |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1400 } |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1401 } |
287 | 1402 |
1403 for(mv=0; mv<MAX_MV*2+1; mv++){ | |
1404 umv_fcode_tab[mv]= 1; | |
1405 } | |
277
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1406 } |
815
78accc54493b
put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents:
770
diff
changeset
|
1407 #endif |
277
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1408 |
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
|
1409 #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
|
1410 |
468 | 1411 static void init_uni_dc_tab(void) |
293 | 1412 { |
1413 int level, uni_code, uni_len; | |
1414 | |
312 | 1415 for(level=-256; level<256; level++){ |
293 | 1416 int size, v, l; |
1417 /* find number of bits */ | |
1418 size = 0; | |
1419 v = abs(level); | |
1420 while (v) { | |
1421 v >>= 1; | |
1422 size++; | |
1423 } | |
1424 | |
1425 if (level < 0) | |
1426 l= (-level) ^ ((1 << size) - 1); | |
1427 else | |
1428 l= level; | |
1429 | |
1430 /* luminance */ | |
1431 uni_code= DCtab_lum[size][0]; | |
1432 uni_len = DCtab_lum[size][1]; | |
1433 | |
1434 if (size > 0) { | |
1435 uni_code<<=size; uni_code|=l; | |
1436 uni_len+=size; | |
1437 if (size > 8){ | |
1438 uni_code<<=1; uni_code|=1; | |
1439 uni_len++; | |
1440 } | |
1441 } | |
1013 | 1442 uni_DCtab_lum_bits[level+256]= uni_code; |
1443 uni_DCtab_lum_len [level+256]= uni_len; | |
293 | 1444 |
1445 /* chrominance */ | |
1446 uni_code= DCtab_chrom[size][0]; | |
1447 uni_len = DCtab_chrom[size][1]; | |
1448 | |
1449 if (size > 0) { | |
1450 uni_code<<=size; uni_code|=l; | |
1451 uni_len+=size; | |
1452 if (size > 8){ | |
1453 uni_code<<=1; uni_code|=1; | |
1454 uni_len++; | |
1455 } | |
1456 } | |
1013 | 1457 uni_DCtab_chrom_bits[level+256]= uni_code; |
1458 uni_DCtab_chrom_len [level+256]= uni_len; | |
293 | 1459 |
1460 } | |
1461 } | |
1462 | |
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
|
1463 #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
|
1464 |
815
78accc54493b
put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents:
770
diff
changeset
|
1465 #ifdef CONFIG_ENCODERS |
1064 | 1466 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
|
1467 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
|
1468 |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1469 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
|
1470 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
|
1471 |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1472 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
|
1473 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
|
1474 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
|
1475 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
|
1476 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
|
1477 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
|
1478 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
|
1479 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
|
1480 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
|
1481 |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1482 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
|
1483 |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1484 /* 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
|
1485 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
|
1486 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
|
1487 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
|
1488 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
|
1489 |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1490 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
|
1491 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
|
1492 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
|
1493 } |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1494 #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
|
1495 /* 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
|
1496 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
|
1497 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
|
1498 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
|
1499 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
|
1500 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
|
1501 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
|
1502 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
|
1503 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
|
1504 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
|
1505 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
|
1506 |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1507 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
|
1508 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
|
1509 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
|
1510 } |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1511 } |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1512 #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
|
1513 #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
|
1514 /* 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
|
1515 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
|
1516 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
|
1517 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
|
1518 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
|
1519 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
|
1520 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
|
1521 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
|
1522 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
|
1523 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
|
1524 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
|
1525 |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1526 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
|
1527 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
|
1528 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
|
1529 } |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1530 } |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1531 #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
|
1532 /* 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
|
1533 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
|
1534 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
|
1535 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
|
1536 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
|
1537 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
|
1538 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
|
1539 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
|
1540 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
|
1541 |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1542 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
|
1543 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
|
1544 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
|
1545 } |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1546 } |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1547 } |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1548 } |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1549 } |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1550 |
277
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1551 void h263_encode_init(MpegEncContext *s) |
0 | 1552 { |
1553 static int done = 0; | |
1554 | |
1555 if (!done) { | |
1556 done = 1; | |
293 | 1557 |
1558 init_uni_dc_tab(); | |
1559 | |
0 | 1560 init_rl(&rl_inter); |
1561 init_rl(&rl_intra); | |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1562 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
|
1563 |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1564 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
|
1565 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
|
1566 |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1567 init_mv_penalty_and_fcode(s); |
0 | 1568 } |
936 | 1569 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
|
1570 |
287 | 1571 // use fcodes >1 only for mpeg4 & h263 & h263p FIXME |
344 | 1572 switch(s->codec_id){ |
1573 case CODEC_ID_MPEG4: | |
1574 s->fcode_tab= fcode_tab; | |
1575 s->min_qcoeff= -2048; | |
1576 s->max_qcoeff= 2047; | |
945 | 1577 s->intra_ac_vlc_length = uni_mpeg4_intra_rl_len; |
1578 s->intra_ac_vlc_last_length= uni_mpeg4_intra_rl_len + 128*64; | |
1579 s->inter_ac_vlc_length = uni_mpeg4_inter_rl_len; | |
1580 s->inter_ac_vlc_last_length= uni_mpeg4_inter_rl_len + 128*64; | |
1013 | 1581 s->luma_dc_vlc_length= uni_DCtab_lum_len; |
1582 s->chroma_dc_vlc_length= uni_DCtab_chrom_len; | |
945 | 1583 s->ac_esc_length= 7+2+1+6+1+12+1; |
1424 | 1584 |
1585 if(s->flags & CODEC_FLAG_GLOBAL_HEADER){ | |
1483 | 1586 |
1424 | 1587 s->avctx->extradata= av_malloc(1024); |
1588 init_put_bits(&s->pb, s->avctx->extradata, 1024, NULL, NULL); | |
1589 | |
1590 mpeg4_encode_visual_object_header(s); | |
1591 mpeg4_encode_vol_header(s, 0, 0); | |
1592 | |
1593 // ff_mpeg4_stuffing(&s->pb); ? | |
1594 flush_put_bits(&s->pb); | |
1595 s->avctx->extradata_size= (get_bit_count(&s->pb)+7)>>3; | |
1596 } | |
1597 | |
344 | 1598 break; |
1599 case CODEC_ID_H263P: | |
1600 s->fcode_tab= umv_fcode_tab; | |
1089 | 1601 s->min_qcoeff= -127; |
344 | 1602 s->max_qcoeff= 127; |
1603 break; | |
498 | 1604 //Note for mpeg4 & h263 the dc-scale table will be set per frame as needed later |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1605 case CODEC_ID_FLV1: |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1606 if (s->h263_flv > 1) { |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1607 s->min_qcoeff= -1023; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1608 s->max_qcoeff= 1023; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1609 } else { |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1610 s->min_qcoeff= -127; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1611 s->max_qcoeff= 127; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1612 } |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1613 s->y_dc_scale_table= |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1614 s->c_dc_scale_table= ff_mpeg1_dc_scale_table; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1615 break; |
344 | 1616 default: //nothing needed default table allready set in mpegvideo.c |
1089 | 1617 s->min_qcoeff= -127; |
344 | 1618 s->max_qcoeff= 127; |
498 | 1619 s->y_dc_scale_table= |
1620 s->c_dc_scale_table= ff_mpeg1_dc_scale_table; | |
344 | 1621 } |
0 | 1622 } |
1623 | |
1034 | 1624 /** |
1625 * encodes a 8x8 block. | |
1626 * @param block the 8x8 block | |
1627 * @param n block index (0-3 are luma, 4-5 are chroma) | |
1628 */ | |
0 | 1629 static void h263_encode_block(MpegEncContext * s, DCTELEM * block, int n) |
1630 { | |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1631 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
|
1632 RLTable *rl; |
0 | 1633 |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1634 rl = &rl_inter; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1635 if (s->mb_intra && !s->h263_aic) { |
231 | 1636 /* DC coef */ |
1089 | 1637 level = block[0]; |
0 | 1638 /* 255 cannot be represented, so we clamp */ |
1639 if (level > 254) { | |
1640 level = 254; | |
1641 block[0] = 254; | |
1642 } | |
231 | 1643 /* 0 cannot be represented also */ |
1089 | 1644 else if (level < 1) { |
231 | 1645 level = 1; |
1646 block[0] = 1; | |
1647 } | |
1090 | 1648 if (level == 128) //FIXME check rv10 |
1089 | 1649 put_bits(&s->pb, 8, 0xff); |
1650 else | |
1651 put_bits(&s->pb, 8, level & 0xff); | |
1652 i = 1; | |
0 | 1653 } else { |
1089 | 1654 i = 0; |
1655 if (s->h263_aic && s->mb_intra) | |
1656 rl = &rl_intra_aic; | |
0 | 1657 } |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1658 |
0 | 1659 /* AC coefs */ |
1660 last_index = s->block_last_index[n]; | |
1661 last_non_zero = i - 1; | |
1662 for (; i <= last_index; i++) { | |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
702
diff
changeset
|
1663 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
|
1664 level = block[j]; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1665 if (level) { |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1666 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
|
1667 last = (i == last_index); |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1668 sign = 0; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1669 slevel = level; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1670 if (level < 0) { |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1671 sign = 1; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1672 level = -level; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1673 } |
0 | 1674 code = get_rl_index(rl, last, run, level); |
1675 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]); | |
1676 if (code == rl->n) { | |
1354 | 1677 if(s->h263_flv <= 1){ |
0 | 1678 put_bits(&s->pb, 1, last); |
1679 put_bits(&s->pb, 6, run); | |
1089 | 1680 |
1681 assert(slevel != 0); | |
1682 | |
1683 if(slevel < 128 && slevel > -128) | |
1684 put_bits(&s->pb, 8, slevel & 0xff); | |
1685 else{ | |
1686 put_bits(&s->pb, 8, 128); | |
1687 put_bits(&s->pb, 5, slevel & 0x1f); | |
1688 put_bits(&s->pb, 6, (slevel>>5)&0x3f); | |
1689 } | |
1354 | 1690 }else{ |
1691 if(slevel < 64 && slevel > -64) { | |
1692 /* 7-bit level */ | |
1693 put_bits(&s->pb, 1, 0); | |
1694 put_bits(&s->pb, 1, last); | |
1695 put_bits(&s->pb, 6, run); | |
1696 | |
1697 put_bits(&s->pb, 7, slevel & 0x7f); | |
1698 } else { | |
1699 /* 11-bit level */ | |
1700 put_bits(&s->pb, 1, 1); | |
1701 put_bits(&s->pb, 1, last); | |
1702 put_bits(&s->pb, 6, run); | |
1703 | |
1704 put_bits(&s->pb, 11, slevel & 0x7ff); | |
1705 } | |
1706 } | |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1707 } else { |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1708 put_bits(&s->pb, 1, sign); |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1709 } |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1710 last_non_zero = i; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1711 } |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1712 } |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1713 } |
815
78accc54493b
put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents:
770
diff
changeset
|
1714 #endif |
0 | 1715 |
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
|
1716 #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
|
1717 |
0 | 1718 /***************************************************/ |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
1719 /** |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
1720 * add mpeg4 stuffing bits (01...1) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
1721 */ |
453 | 1722 void ff_mpeg4_stuffing(PutBitContext * pbc) |
262 | 1723 { |
1724 int length; | |
1725 put_bits(pbc, 1, 0); | |
1726 length= (-get_bit_count(pbc))&7; | |
453 | 1727 if(length) put_bits(pbc, length, (1<<length)-1); |
262 | 1728 } |
1729 | |
327 | 1730 /* must be called before writing the header */ |
1731 void ff_set_mpeg4_time(MpegEncContext * s, int picture_number){ | |
1732 int time_div, time_mod; | |
1733 | |
903 | 1734 if(s->current_picture.pts) |
1735 s->time= (s->current_picture.pts*s->time_increment_resolution + 500*1000)/(1000*1000); | |
654 | 1736 else |
1126
77ccf7fe3bd0
per context frame_rate_base, this should finally fix frame_rate related av sync issues
michaelni
parents:
1118
diff
changeset
|
1737 s->time= av_rescale(picture_number*(int64_t)s->avctx->frame_rate_base, s->time_increment_resolution, s->avctx->frame_rate); |
327 | 1738 time_div= s->time/s->time_increment_resolution; |
1739 time_mod= s->time%s->time_increment_resolution; | |
1740 | |
1741 if(s->pict_type==B_TYPE){ | |
664 | 1742 s->pb_time= s->pp_time - (s->last_non_b_time - s->time); |
327 | 1743 }else{ |
1744 s->last_time_base= s->time_base; | |
1745 s->time_base= time_div; | |
1746 s->pp_time= s->time - s->last_non_b_time; | |
1747 s->last_non_b_time= s->time; | |
1748 } | |
1749 } | |
1750 | |
942 | 1751 static void mpeg4_encode_gop_header(MpegEncContext * s){ |
1752 int hours, minutes, seconds; | |
1753 | |
1754 put_bits(&s->pb, 16, 0); | |
1755 put_bits(&s->pb, 16, GOP_STARTCODE); | |
1756 | |
1757 seconds= s->time/s->time_increment_resolution; | |
1758 minutes= seconds/60; seconds %= 60; | |
1759 hours= minutes/60; minutes %= 60; | |
1760 hours%=24; | |
1761 | |
1762 put_bits(&s->pb, 5, hours); | |
1763 put_bits(&s->pb, 6, minutes); | |
1764 put_bits(&s->pb, 1, 1); | |
1765 put_bits(&s->pb, 6, seconds); | |
1766 | |
1767 put_bits(&s->pb, 1, 0); //closed gov == NO | |
1768 put_bits(&s->pb, 1, 0); //broken link == NO | |
1769 | |
1770 ff_mpeg4_stuffing(&s->pb); | |
1771 } | |
1772 | |
1773 static void mpeg4_encode_visual_object_header(MpegEncContext * s){ | |
1774 int profile_and_level_indication; | |
1775 int vo_ver_id; | |
1776 | |
1777 if(s->max_b_frames || s->quarter_sample){ | |
1778 profile_and_level_indication= 0xF1; // adv simple level 1 | |
1779 vo_ver_id= 5; | |
1780 }else{ | |
1781 profile_and_level_indication= 0x01; // simple level 1 | |
1782 vo_ver_id= 1; | |
1783 } | |
1784 //FIXME levels | |
1785 | |
1786 put_bits(&s->pb, 16, 0); | |
1787 put_bits(&s->pb, 16, VOS_STARTCODE); | |
1350
e7c8051e1849
the reference sw doesnt like some legal headers ...
michaelni
parents:
1346
diff
changeset
|
1788 |
942 | 1789 put_bits(&s->pb, 8, profile_and_level_indication); |
1350
e7c8051e1849
the reference sw doesnt like some legal headers ...
michaelni
parents:
1346
diff
changeset
|
1790 |
942 | 1791 put_bits(&s->pb, 16, 0); |
1792 put_bits(&s->pb, 16, VISUAL_OBJ_STARTCODE); | |
1793 | |
1794 put_bits(&s->pb, 1, 1); | |
1795 put_bits(&s->pb, 4, vo_ver_id); | |
1796 put_bits(&s->pb, 3, 1); //priority | |
1797 | |
1798 put_bits(&s->pb, 4, 1); //visual obj type== video obj | |
1799 | |
1800 put_bits(&s->pb, 1, 0); //video signal type == no clue //FIXME | |
1801 | |
1802 ff_mpeg4_stuffing(&s->pb); | |
1803 } | |
1804 | |
1805 static void mpeg4_encode_vol_header(MpegEncContext * s, int vo_number, int vol_number) | |
0 | 1806 { |
942 | 1807 int vo_ver_id; |
336 | 1808 |
942 | 1809 if(s->max_b_frames || s->quarter_sample){ |
1810 vo_ver_id= 5; | |
923 | 1811 s->vo_type= ADV_SIMPLE_VO_TYPE; |
1812 }else{ | |
942 | 1813 vo_ver_id= 1; |
923 | 1814 s->vo_type= SIMPLE_VO_TYPE; |
1815 } | |
336 | 1816 |
263 | 1817 put_bits(&s->pb, 16, 0); |
942 | 1818 put_bits(&s->pb, 16, 0x100 + vo_number); /* video obj */ |
263 | 1819 put_bits(&s->pb, 16, 0); |
942 | 1820 put_bits(&s->pb, 16, 0x120 + vol_number); /* video obj layer */ |
263 | 1821 |
1822 put_bits(&s->pb, 1, 0); /* random access vol */ | |
336 | 1823 put_bits(&s->pb, 8, s->vo_type); /* video obj type indication */ |
263 | 1824 put_bits(&s->pb, 1, 1); /* is obj layer id= yes */ |
1825 put_bits(&s->pb, 4, vo_ver_id); /* is obj layer ver id */ | |
1826 put_bits(&s->pb, 3, 1); /* is obj layer priority */ | |
880 | 1827 |
887 | 1828 float_aspect_to_info(s, s->avctx->aspect_ratio); |
880 | 1829 |
1830 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
|
1831 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
|
1832 { |
b4bddbde44f3
aspect (ext. par too) support for h263 and mpeg4 (inc. build becouse of new vars)
al3x
parents:
667
diff
changeset
|
1833 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
|
1834 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
|
1835 } |
336 | 1836 |
1837 if(s->low_delay){ | |
1838 put_bits(&s->pb, 1, 1); /* vol control parameters= yes */ | |
341 | 1839 put_bits(&s->pb, 2, 1); /* chroma format YUV 420/YV12 */ |
336 | 1840 put_bits(&s->pb, 1, s->low_delay); |
1841 put_bits(&s->pb, 1, 0); /* vbv parameters= no */ | |
1842 }else{ | |
1843 put_bits(&s->pb, 1, 0); /* vol control parameters= no */ | |
1844 } | |
1845 | |
263 | 1846 put_bits(&s->pb, 2, RECT_SHAPE); /* vol shape= rectangle */ |
1847 put_bits(&s->pb, 1, 1); /* marker bit */ | |
324 | 1848 |
1849 put_bits(&s->pb, 16, s->time_increment_resolution); | |
263 | 1850 if (s->time_increment_bits < 1) |
1851 s->time_increment_bits = 1; | |
1852 put_bits(&s->pb, 1, 1); /* marker bit */ | |
1853 put_bits(&s->pb, 1, 0); /* fixed vop rate=no */ | |
1854 put_bits(&s->pb, 1, 1); /* marker bit */ | |
1855 put_bits(&s->pb, 13, s->width); /* vol width */ | |
1856 put_bits(&s->pb, 1, 1); /* marker bit */ | |
1857 put_bits(&s->pb, 13, s->height); /* vol height */ | |
1858 put_bits(&s->pb, 1, 1); /* marker bit */ | |
697 | 1859 put_bits(&s->pb, 1, s->progressive_sequence ? 0 : 1); |
263 | 1860 put_bits(&s->pb, 1, 1); /* obmc disable */ |
1861 if (vo_ver_id == 1) { | |
1862 put_bits(&s->pb, 1, s->vol_sprite_usage=0); /* sprite enable */ | |
942 | 1863 }else{ |
263 | 1864 put_bits(&s->pb, 2, s->vol_sprite_usage=0); /* sprite enable */ |
1865 } | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
1866 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
1867 s->quant_precision=5; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
1868 put_bits(&s->pb, 1, 0); /* not 8 bit == false */ |
599 | 1869 put_bits(&s->pb, 1, s->mpeg_quant); /* quant type= (0=h263 style)*/ |
1411 | 1870 |
1871 if(s->mpeg_quant){ | |
1872 ff_write_quant_matrix(&s->pb, s->avctx->intra_matrix); | |
1873 ff_write_quant_matrix(&s->pb, s->avctx->inter_matrix); | |
1874 } | |
599 | 1875 |
263 | 1876 if (vo_ver_id != 1) |
936 | 1877 put_bits(&s->pb, 1, s->quarter_sample); |
263 | 1878 put_bits(&s->pb, 1, 1); /* complexity estimation disable */ |
453 | 1879 s->resync_marker= s->rtp_mode; |
1880 put_bits(&s->pb, 1, s->resync_marker ? 0 : 1);/* resync marker disable */ | |
1881 put_bits(&s->pb, 1, s->data_partitioning ? 1 : 0); | |
1882 if(s->data_partitioning){ | |
1883 put_bits(&s->pb, 1, 0); /* no rvlc */ | |
1884 } | |
1885 | |
263 | 1886 if (vo_ver_id != 1){ |
1887 put_bits(&s->pb, 1, 0); /* newpred */ | |
1888 put_bits(&s->pb, 1, 0); /* reduced res vop */ | |
1889 } | |
1890 put_bits(&s->pb, 1, 0); /* scalability */ | |
676 | 1891 |
453 | 1892 ff_mpeg4_stuffing(&s->pb); |
676 | 1893 |
1894 /* user data */ | |
1092 | 1895 if(!(s->flags & CODEC_FLAG_BITEXACT)){ |
676 | 1896 put_bits(&s->pb, 16, 0); |
1897 put_bits(&s->pb, 16, 0x1B2); /* user_data */ | |
1118 | 1898 put_string(&s->pb, LIBAVCODEC_IDENT); |
676 | 1899 ff_mpeg4_stuffing(&s->pb); |
1900 } | |
263 | 1901 } |
1902 | |
1903 /* write mpeg4 VOP header */ | |
1904 void mpeg4_encode_picture_header(MpegEncContext * s, int picture_number) | |
1905 { | |
324 | 1906 int time_incr; |
1907 int time_div, time_mod; | |
1908 | |
453 | 1909 if(s->pict_type==I_TYPE){ |
953 | 1910 if(!(s->flags&CODEC_FLAG_GLOBAL_HEADER)){ |
1350
e7c8051e1849
the reference sw doesnt like some legal headers ...
michaelni
parents:
1346
diff
changeset
|
1911 if(s->strict_std_compliance < 2) //HACK, the reference sw is buggy |
e7c8051e1849
the reference sw doesnt like some legal headers ...
michaelni
parents:
1346
diff
changeset
|
1912 mpeg4_encode_visual_object_header(s); |
e7c8051e1849
the reference sw doesnt like some legal headers ...
michaelni
parents:
1346
diff
changeset
|
1913 if(s->strict_std_compliance < 2 || picture_number==0) //HACK, the reference sw is buggy |
e7c8051e1849
the reference sw doesnt like some legal headers ...
michaelni
parents:
1346
diff
changeset
|
1914 mpeg4_encode_vol_header(s, 0, 0); |
942 | 1915 } |
1916 mpeg4_encode_gop_header(s); | |
453 | 1917 } |
324 | 1918 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
1919 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
|
1920 |
324 | 1921 //printf("num:%d rate:%d base:%d\n", s->picture_number, s->frame_rate, FRAME_RATE_BASE); |
1922 | |
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
|
1923 put_bits(&s->pb, 16, 0); /* vop header */ |
942 | 1924 put_bits(&s->pb, 16, VOP_STARTCODE); /* vop header */ |
0 | 1925 put_bits(&s->pb, 2, s->pict_type - 1); /* pict type: I = 0 , P = 1 */ |
324 | 1926 |
327 | 1927 time_div= s->time/s->time_increment_resolution; |
1928 time_mod= s->time%s->time_increment_resolution; | |
324 | 1929 time_incr= time_div - s->last_time_base; |
1930 while(time_incr--) | |
1931 put_bits(&s->pb, 1, 1); | |
1932 | |
0 | 1933 put_bits(&s->pb, 1, 0); |
1934 | |
1935 put_bits(&s->pb, 1, 1); /* marker */ | |
324 | 1936 put_bits(&s->pb, s->time_increment_bits, time_mod); /* time increment */ |
0 | 1937 put_bits(&s->pb, 1, 1); /* marker */ |
1938 put_bits(&s->pb, 1, 1); /* vop coded */ | |
263 | 1939 if ( s->pict_type == P_TYPE |
1940 || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE)) { | |
0 | 1941 put_bits(&s->pb, 1, s->no_rounding); /* rounding type */ |
1942 } | |
1943 put_bits(&s->pb, 3, 0); /* intra dc VLC threshold */ | |
697 | 1944 if(!s->progressive_sequence){ |
1945 put_bits(&s->pb, 1, s->top_field_first); | |
1946 put_bits(&s->pb, 1, s->alternate_scan); | |
1947 } | |
263 | 1948 //FIXME sprite stuff |
0 | 1949 |
1950 put_bits(&s->pb, 5, s->qscale); | |
1951 | |
1952 if (s->pict_type != I_TYPE) | |
1953 put_bits(&s->pb, 3, s->f_code); /* fcode_for */ | |
263 | 1954 if (s->pict_type == B_TYPE) |
1955 put_bits(&s->pb, 3, s->b_code); /* fcode_back */ | |
0 | 1956 // printf("****frame %d\n", picture_number); |
498 | 1957 |
1958 s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table; //FIXME add short header support | |
1959 s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table; | |
0 | 1960 } |
1961 | |
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
|
1962 #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
|
1963 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
1964 /** |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
1965 * 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
|
1966 */ |
698 | 1967 static void change_qscale(MpegEncContext * s, int dquant) |
0 | 1968 { |
698 | 1969 s->qscale += dquant; |
1970 | |
1971 if (s->qscale < 1) | |
1972 s->qscale = 1; | |
1973 else if (s->qscale > 31) | |
1974 s->qscale = 31; | |
1975 | |
498 | 1976 s->y_dc_scale= s->y_dc_scale_table[ s->qscale ]; |
1977 s->c_dc_scale= s->c_dc_scale_table[ s->qscale ]; | |
0 | 1978 } |
1979 | |
1034 | 1980 /** |
1981 * predicts the dc. | |
1982 * @param n block index (0-3 are luma, 4-5 are chroma) | |
1983 * @param dc_val_ptr a pointer to the dc_val entry for the current MB will be stored here | |
1984 * @param dir_ptr pointer to an integer where the prediction direction will be stored | |
1985 * @return the quantized predicted dc | |
1986 */ | |
1064 | 1987 static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, uint16_t **dc_val_ptr, int *dir_ptr) |
0 | 1988 { |
266 | 1989 int a, b, c, wrap, pred, scale; |
1064 | 1990 uint16_t *dc_val; |
0 | 1991 |
1992 /* find prediction */ | |
1993 if (n < 4) { | |
1994 scale = s->y_dc_scale; | |
1995 } else { | |
1996 scale = s->c_dc_scale; | |
1997 } | |
1271
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
1998 if(IS_3IV1) |
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
1999 scale= 8; |
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
2000 |
266 | 2001 wrap= s->block_wrap[n]; |
2002 dc_val = s->dc_val[0] + s->block_index[n]; | |
0 | 2003 |
2004 /* B C | |
2005 * A X | |
2006 */ | |
266 | 2007 a = dc_val[ - 1]; |
2008 b = dc_val[ - 1 - wrap]; | |
2009 c = dc_val[ - wrap]; | |
0 | 2010 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2011 /* 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
|
2012 if(s->first_slice_line && n!=3){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2013 if(n!=2) b=c= 1024; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2014 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
|
2015 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2016 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
|
2017 if(n==0 || n==4 || n==5) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2018 b=1024; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2019 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2020 |
0 | 2021 if (abs(a - b) < abs(b - c)) { |
2022 pred = c; | |
2023 *dir_ptr = 1; /* top */ | |
2024 } else { | |
2025 pred = a; | |
2026 *dir_ptr = 0; /* left */ | |
2027 } | |
2028 /* we assume pred is positive */ | |
1261
362947395f5c
fastdiv patch by (BERO <bero at geocities dot co dot jp>) with fixes & cleanup by me
michaelni
parents:
1257
diff
changeset
|
2029 pred = FASTDIV((pred + (scale >> 1)), scale); |
0 | 2030 |
2031 /* prepare address for prediction update */ | |
266 | 2032 *dc_val_ptr = &dc_val[0]; |
0 | 2033 |
2034 return pred; | |
2035 } | |
2036 | |
1034 | 2037 /** |
2038 * predicts the ac. | |
2039 * @param n block index (0-3 are luma, 4-5 are chroma) | |
2040 * @param dir the ac prediction direction | |
2041 */ | |
1008 | 2042 void mpeg4_pred_ac(MpegEncContext * s, DCTELEM *block, int n, |
0 | 2043 int dir) |
2044 { | |
266 | 2045 int i; |
1064 | 2046 int16_t *ac_val, *ac_val1; |
903 | 2047 int8_t * const qscale_table= s->current_picture.qscale_table; |
0 | 2048 |
2049 /* find prediction */ | |
266 | 2050 ac_val = s->ac_val[0][0] + s->block_index[n] * 16; |
0 | 2051 ac_val1 = ac_val; |
2052 if (s->ac_pred) { | |
2053 if (dir == 0) { | |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
2054 const int xy= s->mb_x-1 + s->mb_y*s->mb_stride; |
0 | 2055 /* left prediction */ |
2056 ac_val -= 16; | |
575 | 2057 |
903 | 2058 if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){ |
575 | 2059 /* same qscale */ |
2060 for(i=1;i<8;i++) { | |
1092 | 2061 block[s->dsp.idct_permutation[i<<3]] += ac_val[i]; |
575 | 2062 } |
2063 }else{ | |
2064 /* different qscale, we must rescale */ | |
2065 for(i=1;i<8;i++) { | |
1092 | 2066 block[s->dsp.idct_permutation[i<<3]] += ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale); |
575 | 2067 } |
0 | 2068 } |
2069 } else { | |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
2070 const int xy= s->mb_x + s->mb_y*s->mb_stride - s->mb_stride; |
0 | 2071 /* top prediction */ |
266 | 2072 ac_val -= 16 * s->block_wrap[n]; |
575 | 2073 |
903 | 2074 if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){ |
575 | 2075 /* same qscale */ |
2076 for(i=1;i<8;i++) { | |
1092 | 2077 block[s->dsp.idct_permutation[i]] += ac_val[i + 8]; |
575 | 2078 } |
2079 }else{ | |
2080 /* different qscale, we must rescale */ | |
2081 for(i=1;i<8;i++) { | |
1092 | 2082 block[s->dsp.idct_permutation[i]] += ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale); |
575 | 2083 } |
0 | 2084 } |
2085 } | |
2086 } | |
2087 /* left copy */ | |
2088 for(i=1;i<8;i++) | |
1092 | 2089 ac_val1[i ] = block[s->dsp.idct_permutation[i<<3]]; |
591 | 2090 |
0 | 2091 /* top copy */ |
2092 for(i=1;i<8;i++) | |
1092 | 2093 ac_val1[8 + i] = block[s->dsp.idct_permutation[i ]]; |
591 | 2094 |
0 | 2095 } |
2096 | |
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
|
2097 #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
|
2098 |
1008 | 2099 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
|
2100 int dir) |
0 | 2101 { |
266 | 2102 int i; |
1064 | 2103 int16_t *ac_val; |
903 | 2104 int8_t * const qscale_table= s->current_picture.qscale_table; |
0 | 2105 |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
2106 /* find prediction */ |
266 | 2107 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
|
2108 |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
2109 if (dir == 0) { |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
2110 const int xy= s->mb_x-1 + s->mb_y*s->mb_stride; |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
2111 /* left prediction */ |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
2112 ac_val -= 16; |
903 | 2113 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
|
2114 /* same qscale */ |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
2115 for(i=1;i<8;i++) { |
1092 | 2116 block[s->dsp.idct_permutation[i<<3]] -= ac_val[i]; |
692
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
2117 } |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
2118 }else{ |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
2119 /* different qscale, we must rescale */ |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
2120 for(i=1;i<8;i++) { |
1092 | 2121 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
|
2122 } |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
2123 } |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
2124 } else { |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
2125 const int xy= s->mb_x + s->mb_y*s->mb_stride - s->mb_stride; |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
2126 /* top prediction */ |
266 | 2127 ac_val -= 16 * s->block_wrap[n]; |
903 | 2128 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
|
2129 /* same qscale */ |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
2130 for(i=1;i<8;i++) { |
1092 | 2131 block[s->dsp.idct_permutation[i]] -= ac_val[i + 8]; |
692
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
2132 } |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
2133 }else{ |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
2134 /* different qscale, we must rescale */ |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
2135 for(i=1;i<8;i++) { |
1092 | 2136 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
|
2137 } |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
2138 } |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
2139 } |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
2140 } |
0 | 2141 |
1034 | 2142 /** |
2143 * encodes the dc value. | |
2144 * @param n block index (0-3 are luma, 4-5 are chroma) | |
2145 */ | |
453 | 2146 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
|
2147 { |
293 | 2148 #if 1 |
453 | 2149 // if(level<-255 || level>255) printf("dc overflow\n"); |
293 | 2150 level+=256; |
2151 if (n < 4) { | |
2152 /* luminance */ | |
1013 | 2153 put_bits(s, uni_DCtab_lum_len[level], uni_DCtab_lum_bits[level]); |
293 | 2154 } else { |
2155 /* chrominance */ | |
1013 | 2156 put_bits(s, uni_DCtab_chrom_len[level], uni_DCtab_chrom_bits[level]); |
293 | 2157 } |
2158 #else | |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
2159 int size, v; |
0 | 2160 /* find number of bits */ |
2161 size = 0; | |
2162 v = abs(level); | |
2163 while (v) { | |
2164 v >>= 1; | |
2165 size++; | |
2166 } | |
2167 | |
2168 if (n < 4) { | |
2169 /* luminance */ | |
2170 put_bits(&s->pb, DCtab_lum[size][1], DCtab_lum[size][0]); | |
2171 } else { | |
2172 /* chrominance */ | |
2173 put_bits(&s->pb, DCtab_chrom[size][1], DCtab_chrom[size][0]); | |
2174 } | |
2175 | |
2176 /* encode remaining bits */ | |
2177 if (size > 0) { | |
2178 if (level < 0) | |
2179 level = (-level) ^ ((1 << size) - 1); | |
2180 put_bits(&s->pb, size, level); | |
2181 if (size > 8) | |
2182 put_bits(&s->pb, 1, 1); | |
2183 } | |
293 | 2184 #endif |
0 | 2185 } |
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
|
2186 |
1034 | 2187 /** |
2188 * encodes a 8x8 block | |
2189 * @param n block index (0-3 are luma, 4-5 are chroma) | |
2190 */ | |
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
|
2191 static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n, int intra_dc, |
1064 | 2192 uint8_t *scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb) |
0 | 2193 { |
751 | 2194 int i, last_non_zero; |
2195 #if 0 //variables for the outcommented version | |
2196 int code, sign, last; | |
2197 #endif | |
0 | 2198 const RLTable *rl; |
1064 | 2199 uint32_t *bits_tab; |
2200 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
|
2201 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
|
2202 |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
2203 if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away |
0 | 2204 /* mpeg4 based DC predictor */ |
453 | 2205 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
|
2206 if(last_index<1) return; |
0 | 2207 i = 1; |
2208 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
|
2209 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
|
2210 len_tab = uni_mpeg4_intra_rl_len; |
0 | 2211 } 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
|
2212 if(last_index<0) return; |
0 | 2213 i = 0; |
2214 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
|
2215 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
|
2216 len_tab = uni_mpeg4_inter_rl_len; |
0 | 2217 } |
2218 | |
2219 /* AC coefs */ | |
2220 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
|
2221 #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
|
2222 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
|
2223 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
|
2224 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
|
2225 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
|
2226 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
|
2227 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
|
2228 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
|
2229 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
|
2230 }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
|
2231 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
|
2232 } |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
2233 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
|
2234 } |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
2235 } |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
2236 /*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
|
2237 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
|
2238 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
|
2239 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
|
2240 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
|
2241 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
|
2242 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
|
2243 }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
|
2244 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
|
2245 } |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
2246 } |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
2247 #else |
0 | 2248 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
|
2249 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
|
2250 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
|
2251 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
|
2252 int run = i - last_non_zero - 1; |
0 | 2253 last = (i == last_index); |
2254 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
|
2255 level = slevel; |
0 | 2256 if (level < 0) { |
2257 sign = 1; | |
2258 level = -level; | |
2259 } | |
2260 code = get_rl_index(rl, last, run, level); | |
453 | 2261 put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]); |
0 | 2262 if (code == rl->n) { |
2263 int level1, run1; | |
2264 level1 = level - rl->max_level[last][run]; | |
2265 if (level1 < 1) | |
2266 goto esc2; | |
2267 code = get_rl_index(rl, last, run, level1); | |
2268 if (code == rl->n) { | |
2269 esc2: | |
453 | 2270 put_bits(ac_pb, 1, 1); |
0 | 2271 if (level > MAX_LEVEL) |
2272 goto esc3; | |
2273 run1 = run - rl->max_run[last][level] - 1; | |
2274 if (run1 < 0) | |
2275 goto esc3; | |
2276 code = get_rl_index(rl, last, run1, level); | |
2277 if (code == rl->n) { | |
2278 esc3: | |
2279 /* third escape */ | |
453 | 2280 put_bits(ac_pb, 1, 1); |
2281 put_bits(ac_pb, 1, last); | |
2282 put_bits(ac_pb, 6, run); | |
2283 put_bits(ac_pb, 1, 1); | |
2284 put_bits(ac_pb, 12, slevel & 0xfff); | |
2285 put_bits(ac_pb, 1, 1); | |
0 | 2286 } else { |
2287 /* second escape */ | |
453 | 2288 put_bits(ac_pb, 1, 0); |
2289 put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]); | |
2290 put_bits(ac_pb, 1, sign); | |
0 | 2291 } |
2292 } else { | |
2293 /* first escape */ | |
453 | 2294 put_bits(ac_pb, 1, 0); |
2295 put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]); | |
2296 put_bits(ac_pb, 1, sign); | |
0 | 2297 } |
2298 } else { | |
453 | 2299 put_bits(ac_pb, 1, sign); |
0 | 2300 } |
2301 last_non_zero = i; | |
2302 } | |
2303 } | |
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
|
2304 #endif |
0 | 2305 } |
936 | 2306 |
2307 static inline int mpeg4_get_block_length(MpegEncContext * s, DCTELEM * block, int n, int intra_dc, | |
1064 | 2308 uint8_t *scan_table) |
936 | 2309 { |
2310 int i, last_non_zero; | |
2311 const RLTable *rl; | |
1064 | 2312 uint8_t *len_tab; |
936 | 2313 const int last_index = s->block_last_index[n]; |
2314 int len=0; | |
2315 | |
2316 if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away | |
2317 /* mpeg4 based DC predictor */ | |
2318 //mpeg4_encode_dc(dc_pb, intra_dc, n); //FIXME | |
2319 if(last_index<1) return len; | |
2320 i = 1; | |
2321 rl = &rl_intra; | |
2322 len_tab = uni_mpeg4_intra_rl_len; | |
2323 } else { | |
2324 if(last_index<0) return 0; | |
2325 i = 0; | |
2326 rl = &rl_inter; | |
2327 len_tab = uni_mpeg4_inter_rl_len; | |
2328 } | |
2329 | |
2330 /* AC coefs */ | |
2331 last_non_zero = i - 1; | |
2332 for (; i < last_index; i++) { | |
2333 int level = block[ scan_table[i] ]; | |
2334 if (level) { | |
2335 int run = i - last_non_zero - 1; | |
2336 level+=64; | |
2337 if((level&(~127)) == 0){ | |
2338 const int index= UNI_MPEG4_ENC_INDEX(0, run, level); | |
2339 len += len_tab[index]; | |
2340 }else{ //ESC3 | |
2341 len += 7+2+1+6+1+12+1; | |
2342 } | |
2343 last_non_zero = i; | |
2344 } | |
2345 } | |
2346 /*if(i<=last_index)*/{ | |
2347 int level = block[ scan_table[i] ]; | |
2348 int run = i - last_non_zero - 1; | |
2349 level+=64; | |
2350 if((level&(~127)) == 0){ | |
2351 const int index= UNI_MPEG4_ENC_INDEX(1, run, level); | |
2352 len += len_tab[index]; | |
2353 }else{ //ESC3 | |
2354 len += 7+2+1+6+1+12+1; | |
2355 } | |
2356 } | |
2357 | |
2358 return len; | |
2359 } | |
2360 | |
815
78accc54493b
put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents:
770
diff
changeset
|
2361 #endif |
0 | 2362 |
2363 | |
2364 /***********************************************/ | |
2365 /* decoding */ | |
2366 | |
2367 static VLC intra_MCBPC_vlc; | |
2368 static VLC inter_MCBPC_vlc; | |
2369 static VLC cbpy_vlc; | |
2370 static VLC mv_vlc; | |
2371 static VLC dc_lum, dc_chrom; | |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
2372 static VLC sprite_trajectory; |
262 | 2373 static VLC mb_type_b_vlc; |
0 | 2374 |
2375 void init_vlc_rl(RLTable *rl) | |
2376 { | |
542 | 2377 int i, q; |
2378 | |
0 | 2379 init_vlc(&rl->vlc, 9, rl->n + 1, |
2380 &rl->table_vlc[0][1], 4, 2, | |
2381 &rl->table_vlc[0][0], 4, 2); | |
542 | 2382 |
2383 | |
2384 for(q=0; q<32; q++){ | |
2385 int qmul= q*2; | |
2386 int qadd= (q-1)|1; | |
2387 | |
2388 if(q==0){ | |
2389 qmul=1; | |
2390 qadd=0; | |
2391 } | |
2392 | |
2393 rl->rl_vlc[q]= av_malloc(rl->vlc.table_size*sizeof(RL_VLC_ELEM)); | |
2394 for(i=0; i<rl->vlc.table_size; i++){ | |
2395 int code= rl->vlc.table[i][0]; | |
2396 int len = rl->vlc.table[i][1]; | |
2397 int level, run; | |
2398 | |
2399 if(len==0){ // illegal code | |
563 | 2400 run= 66; |
542 | 2401 level= MAX_LEVEL; |
2402 }else if(len<0){ //more bits needed | |
2403 run= 0; | |
2404 level= code; | |
2405 }else{ | |
2406 if(code==rl->n){ //esc | |
563 | 2407 run= 66; |
542 | 2408 level= 0; |
2409 }else{ | |
2410 run= rl->table_run [code] + 1; | |
2411 level= rl->table_level[code] * qmul + qadd; | |
2412 if(code >= rl->last) run+=192; | |
2413 } | |
2414 } | |
2415 rl->rl_vlc[q][i].len= len; | |
2416 rl->rl_vlc[q][i].level= level; | |
2417 rl->rl_vlc[q][i].run= run; | |
2418 } | |
2419 } | |
0 | 2420 } |
2421 | |
2422 /* init vlcs */ | |
2423 | |
2424 /* XXX: find a better solution to handle static init */ | |
2425 void h263_decode_init_vlc(MpegEncContext *s) | |
2426 { | |
2427 static int done = 0; | |
2428 | |
2429 if (!done) { | |
2430 done = 1; | |
2431 | |
1482 | 2432 init_vlc(&intra_MCBPC_vlc, INTRA_MCBPC_VLC_BITS, 9, |
0 | 2433 intra_MCBPC_bits, 1, 1, |
2434 intra_MCBPC_code, 1, 1); | |
1482 | 2435 init_vlc(&inter_MCBPC_vlc, INTER_MCBPC_VLC_BITS, 28, |
0 | 2436 inter_MCBPC_bits, 1, 1, |
2437 inter_MCBPC_code, 1, 1); | |
544 | 2438 init_vlc(&cbpy_vlc, CBPY_VLC_BITS, 16, |
0 | 2439 &cbpy_tab[0][1], 2, 1, |
2440 &cbpy_tab[0][0], 2, 1); | |
544 | 2441 init_vlc(&mv_vlc, MV_VLC_BITS, 33, |
0 | 2442 &mvtab[0][1], 2, 1, |
2443 &mvtab[0][0], 2, 1); | |
2444 init_rl(&rl_inter); | |
2445 init_rl(&rl_intra); | |
1132 | 2446 init_rl(&rvlc_rl_inter); |
2447 init_rl(&rvlc_rl_intra); | |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
2448 init_rl(&rl_intra_aic); |
0 | 2449 init_vlc_rl(&rl_inter); |
2450 init_vlc_rl(&rl_intra); | |
1132 | 2451 init_vlc_rl(&rvlc_rl_inter); |
2452 init_vlc_rl(&rvlc_rl_intra); | |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
2453 init_vlc_rl(&rl_intra_aic); |
549 | 2454 init_vlc(&dc_lum, DC_VLC_BITS, 10 /* 13 */, |
0 | 2455 &DCtab_lum[0][1], 2, 1, |
2456 &DCtab_lum[0][0], 2, 1); | |
549 | 2457 init_vlc(&dc_chrom, DC_VLC_BITS, 10 /* 13 */, |
0 | 2458 &DCtab_chrom[0][1], 2, 1, |
2459 &DCtab_chrom[0][0], 2, 1); | |
544 | 2460 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
|
2461 &sprite_trajectory_tab[0][1], 4, 2, |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
2462 &sprite_trajectory_tab[0][0], 4, 2); |
544 | 2463 init_vlc(&mb_type_b_vlc, MB_TYPE_B_VLC_BITS, 4, |
262 | 2464 &mb_type_b_tab[0][1], 2, 1, |
2465 &mb_type_b_tab[0][0], 2, 1); | |
0 | 2466 } |
2467 } | |
2468 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2469 /** |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2470 * 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
|
2471 */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2472 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
|
2473 if (s->height <= 400) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2474 return 1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2475 else if (s->height <= 800) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2476 return 2; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2477 else |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2478 return 4; |
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 |
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 * decodes the group of blocks header. |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2483 * @return <0 if an error occured |
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 static int h263_decode_gob_header(MpegEncContext *s) |
162 | 2486 { |
2487 unsigned int val, gfid; | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2488 int left; |
162 | 2489 |
2490 /* Check for GOB Start Code */ | |
2491 val = show_bits(&s->gb, 16); | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2492 if(val) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2493 return -1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2494 |
162 | 2495 /* 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
|
2496 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
|
2497 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
|
2498 //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
|
2499 for(;left>13; left--){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2500 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
|
2501 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2502 if(left<=13) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2503 return -1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2504 |
162 | 2505 #ifdef DEBUG |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2506 fprintf(stderr,"\nGOB Start Code at MB %d\n", (s->mb_y * s->mb_width) + s->mb_x); |
162 | 2507 #endif |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2508 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
|
2509 gfid = get_bits(&s->gb, 2); /* GFID */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2510 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
|
2511 if(s->qscale==0) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2512 return -1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2513 s->mb_x= 0; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2514 s->mb_y= s->gob_index* s->gob_number; |
1393 | 2515 if(s->mb_y >= s->mb_height) |
2516 return -1; | |
162 | 2517 #ifdef DEBUG |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2518 fprintf(stderr, "\nGN: %u GFID: %u Quant: %u\n", s->gob_number, gfid, s->qscale); |
162 | 2519 #endif |
2520 return 0; | |
2521 } | |
2522 | |
290 | 2523 static inline void memsetw(short *tab, int val, int n) |
2524 { | |
2525 int i; | |
2526 for(i=0;i<n;i++) | |
2527 tab[i] = val; | |
2528 } | |
2529 | |
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
|
2530 #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
|
2531 |
453 | 2532 void ff_mpeg4_init_partitions(MpegEncContext *s) |
2533 { | |
2534 init_put_bits(&s->tex_pb, s->tex_pb_buffer, PB_BUFFER_SIZE, NULL, NULL); | |
2535 init_put_bits(&s->pb2 , s->pb2_buffer , PB_BUFFER_SIZE, NULL, NULL); | |
2536 } | |
2537 | |
2538 void ff_mpeg4_merge_partitions(MpegEncContext *s) | |
290 | 2539 { |
453 | 2540 const int pb2_len = get_bit_count(&s->pb2 ); |
2541 const int tex_pb_len= get_bit_count(&s->tex_pb); | |
2542 const int bits= get_bit_count(&s->pb); | |
2543 | |
2544 if(s->pict_type==I_TYPE){ | |
2545 put_bits(&s->pb, 19, DC_MARKER); | |
2546 s->misc_bits+=19 + pb2_len + bits - s->last_bits; | |
2547 s->i_tex_bits+= tex_pb_len; | |
2548 }else{ | |
2549 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
|
2550 s->misc_bits+=17 + pb2_len; |
453 | 2551 s->mv_bits+= bits - s->last_bits; |
2552 s->p_tex_bits+= tex_pb_len; | |
2553 } | |
2554 | |
2555 flush_put_bits(&s->pb2); | |
2556 flush_put_bits(&s->tex_pb); | |
2557 | |
2558 ff_copy_bits(&s->pb, s->pb2_buffer , pb2_len); | |
2559 ff_copy_bits(&s->pb, s->tex_pb_buffer, tex_pb_len); | |
2560 s->last_bits= get_bit_count(&s->pb); | |
2561 } | |
2562 | |
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
|
2563 #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
|
2564 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2565 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
|
2566 switch(s->pict_type){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2567 case I_TYPE: |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2568 return 16; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2569 case P_TYPE: |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2570 case S_TYPE: |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2571 return s->f_code+15; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2572 case B_TYPE: |
847 | 2573 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
|
2574 default: |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2575 return -1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2576 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2577 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2578 |
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
|
2579 #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
|
2580 |
453 | 2581 void ff_mpeg4_encode_video_packet_header(MpegEncContext *s) |
2582 { | |
2583 int mb_num_bits= av_log2(s->mb_num - 1) + 1; | |
2584 | |
2585 ff_mpeg4_stuffing(&s->pb); | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2586 put_bits(&s->pb, ff_mpeg4_get_video_packet_prefix_length(s), 0); |
453 | 2587 put_bits(&s->pb, 1, 1); |
2588 | |
2589 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
|
2590 put_bits(&s->pb, s->quant_precision, s->qscale); |
453 | 2591 put_bits(&s->pb, 1, 0); /* no HEC */ |
2592 } | |
2593 | |
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
|
2594 #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
|
2595 |
453 | 2596 /** |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2597 * 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
|
2598 * @return 0 if not |
453 | 2599 */ |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2600 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
|
2601 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
|
2602 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2603 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
|
2604 return 0; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2605 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2606 |
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
|
2607 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
|
2608 int v= show_bits(&s->gb, 8); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2609 v|= 0x7F >> (7-(bits_count&7)); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2610 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2611 if(v==0x7F) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2612 return 1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2613 }else{ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2614 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
|
2615 int len; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2616 GetBitContext gb= s->gb; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2617 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2618 skip_bits(&s->gb, 1); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2619 align_get_bits(&s->gb); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2620 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2621 for(len=0; len<32; len++){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2622 if(get_bits1(&s->gb)) break; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2623 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2624 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2625 s->gb= gb; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2626 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2627 if(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
|
2628 return 1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2629 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2630 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2631 return 0; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2632 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2633 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2634 /** |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2635 * decodes the next video packet. |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2636 * @return <0 if something went wrong |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2637 */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2638 static int mpeg4_decode_video_packet_header(MpegEncContext *s) |
453 | 2639 { |
290 | 2640 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
|
2641 int header_extension=0, mb_num, len; |
453 | 2642 |
2643 /* 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
|
2644 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
|
2645 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2646 for(len=0; len<32; len++){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2647 if(get_bits1(&s->gb)) break; |
453 | 2648 } |
2649 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2650 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
|
2651 printf("marker does not match f_code\n"); |
453 | 2652 return -1; |
2653 } | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2654 |
453 | 2655 if(s->shape != RECT_SHAPE){ |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2656 header_extension= get_bits1(&s->gb); |
453 | 2657 //FIXME more stuff here |
2658 } | |
2659 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2660 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
|
2661 if(mb_num>=s->mb_num){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2662 fprintf(stderr, "illegal mb_num in video packet (%d %d) \n", mb_num, s->mb_num); |
453 | 2663 return -1; |
2664 } | |
1176 | 2665 if(s->pict_type == B_TYPE){ |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
2666 while(s->next_picture.mbskip_table[ s->mb_index2xy[ mb_num ] ]) mb_num++; |
1176 | 2667 if(mb_num >= s->mb_num) return -1; // slice contains just skiped MBs which where allready decoded |
2668 } | |
2669 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2670 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
|
2671 s->mb_y= mb_num / s->mb_width; |
453 | 2672 |
2673 if(s->shape != BIN_ONLY_SHAPE){ | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2674 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
|
2675 if(qscale) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2676 s->qscale= qscale; |
290 | 2677 } |
2678 | |
2679 if(s->shape == RECT_SHAPE){ | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2680 header_extension= get_bits1(&s->gb); |
290 | 2681 } |
2682 if(header_extension){ | |
453 | 2683 int time_increment; |
290 | 2684 int time_incr=0; |
453 | 2685 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2686 while (get_bits1(&s->gb) != 0) |
290 | 2687 time_incr++; |
2688 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2689 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
|
2690 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
|
2691 check_marker(&s->gb, "before vop_coding_type in video packed header"); |
290 | 2692 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2693 skip_bits(&s->gb, 2); /* vop coding type */ |
290 | 2694 //FIXME not rect stuff here |
2695 | |
2696 if(s->shape != BIN_ONLY_SHAPE){ | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2697 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
|
2698 //FIXME dont just ignore everything |
821 | 2699 if(s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE){ |
290 | 2700 mpeg4_decode_sprite_trajectory(s); |
660 | 2701 fprintf(stderr, "untested\n"); |
290 | 2702 } |
2703 | |
2704 //FIXME reduced res stuff here | |
2705 | |
2706 if (s->pict_type != I_TYPE) { | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2707 int f_code = get_bits(&s->gb, 3); /* fcode_for */ |
660 | 2708 if(f_code==0){ |
2709 printf("Error, video packet header damaged (f_code=0)\n"); | |
290 | 2710 } |
2711 } | |
2712 if (s->pict_type == B_TYPE) { | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2713 int b_code = get_bits(&s->gb, 3); |
660 | 2714 if(b_code==0){ |
2715 printf("Error, video packet header damaged (b_code=0)\n"); | |
2716 } | |
290 | 2717 } |
2718 } | |
2719 } | |
2720 //FIXME new-pred stuff | |
453 | 2721 |
2722 //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)); | |
2723 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2724 return 0; |
453 | 2725 } |
2726 | |
2727 void ff_mpeg4_clean_buffers(MpegEncContext *s) | |
2728 { | |
2729 int c_wrap, c_xy, l_wrap, l_xy; | |
290 | 2730 |
2731 l_wrap= s->block_wrap[0]; | |
453 | 2732 l_xy= s->mb_y*l_wrap*2 + s->mb_x*2; |
290 | 2733 c_wrap= s->block_wrap[4]; |
453 | 2734 c_xy= s->mb_y*c_wrap + s->mb_x; |
290 | 2735 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2736 #if 0 |
290 | 2737 /* clean DC */ |
453 | 2738 memsetw(s->dc_val[0] + l_xy, 1024, l_wrap*2+1); |
2739 memsetw(s->dc_val[1] + c_xy, 1024, c_wrap+1); | |
2740 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
|
2741 #endif |
290 | 2742 |
2743 /* clean AC */ | |
1064 | 2744 memset(s->ac_val[0] + l_xy, 0, (l_wrap*2+1)*16*sizeof(int16_t)); |
2745 memset(s->ac_val[1] + c_xy, 0, (c_wrap +1)*16*sizeof(int16_t)); | |
2746 memset(s->ac_val[2] + c_xy, 0, (c_wrap +1)*16*sizeof(int16_t)); | |
290 | 2747 |
2748 /* clean MV */ | |
453 | 2749 // we cant clear the MVs as they might be needed by a b frame |
1064 | 2750 // memset(s->motion_val + l_xy, 0, (l_wrap*2+1)*2*sizeof(int16_t)); |
2751 // memset(s->motion_val, 0, 2*sizeof(int16_t)*(2 + s->mb_width*2)*(2 + s->mb_height*2)); | |
453 | 2752 s->last_mv[0][0][0]= |
2753 s->last_mv[0][0][1]= | |
2754 s->last_mv[1][0][0]= | |
2755 s->last_mv[1][0][1]= 0; | |
2756 } | |
2757 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2758 /** |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2759 * 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
|
2760 * @return <0 if no resync found |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2761 */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2762 int ff_h263_resync(MpegEncContext *s){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2763 int left, ret; |
453 | 2764 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2765 if(s->codec_id==CODEC_ID_MPEG4) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2766 skip_bits1(&s->gb); |
453 | 2767 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2768 align_get_bits(&s->gb); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2769 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2770 if(show_bits(&s->gb, 16)==0){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2771 if(s->codec_id==CODEC_ID_MPEG4) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2772 ret= mpeg4_decode_video_packet_header(s); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2773 else |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2774 ret= h263_decode_gob_header(s); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2775 if(ret>=0) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2776 return 0; |
453 | 2777 } |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2778 //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
|
2779 s->gb= s->last_resync_gb; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2780 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
|
2781 left= s->gb.size_in_bits - get_bits_count(&s->gb); |
453 | 2782 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2783 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
|
2784 if(show_bits(&s->gb, 16)==0){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2785 GetBitContext bak= s->gb; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2786 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2787 if(s->codec_id==CODEC_ID_MPEG4) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2788 ret= mpeg4_decode_video_packet_header(s); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2789 else |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2790 ret= h263_decode_gob_header(s); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2791 if(ret>=0) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2792 return 0; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2793 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2794 s->gb= bak; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2795 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2796 skip_bits(&s->gb, 8); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2797 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2798 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2799 return -1; |
453 | 2800 } |
2801 | |
2802 /** | |
1034 | 2803 * gets the average motion vector for a GMC MB. |
753 | 2804 * @param n either 0 for the x component or 1 for y |
2805 * @returns the average MV for a GMC MB | |
2806 */ | |
2807 static inline int get_amv(MpegEncContext *s, int n){ | |
2808 int x, y, mb_v, sum, dx, dy, shift; | |
2809 int len = 1 << (s->f_code + 4); | |
2810 const int a= s->sprite_warping_accuracy; | |
2811 | |
2812 if(s->real_sprite_warping_points==1){ | |
2813 if(s->divx_version==500 && s->divx_build==413) | |
2814 sum= s->sprite_offset[0][n] / (1<<(a - s->quarter_sample)); | |
2815 else | |
2816 sum= RSHIFT(s->sprite_offset[0][n]<<s->quarter_sample, a); | |
2817 }else{ | |
2818 dx= s->sprite_delta[n][0]; | |
2819 dy= s->sprite_delta[n][1]; | |
2820 shift= s->sprite_shift[0]; | |
2821 if(n) dy -= 1<<(shift + a + 1); | |
2822 else dx -= 1<<(shift + a + 1); | |
2823 mb_v= s->sprite_offset[0][n] + dx*s->mb_x*16 + dy*s->mb_y*16; | |
2824 | |
2825 sum=0; | |
2826 for(y=0; y<16; y++){ | |
2827 int v; | |
2828 | |
2829 v= mb_v + dy*y; | |
2830 //XXX FIXME optimize | |
2831 for(x=0; x<16; x++){ | |
2832 sum+= v>>shift; | |
2833 v+= dx; | |
2834 } | |
2835 } | |
999
74dc4105e147
average motion vector rounding like the reference says and not what the standard says
michaelni
parents:
953
diff
changeset
|
2836 sum= RSHIFT(sum, a+8-s->quarter_sample); |
753 | 2837 } |
2838 | |
2839 if (sum < -len) sum= -len; | |
2840 else if (sum >= len) sum= len-1; | |
2841 | |
2842 return sum; | |
2843 } | |
2844 | |
2845 /** | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2846 * decodes first partition. |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2847 * @return number of MBs decoded or <0 if an error occured |
453 | 2848 */ |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2849 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
|
2850 int mb_num; |
1064 | 2851 static const int8_t quant_tab[4] = { -1, -2, 1, 2 }; |
453 | 2852 |
2853 /* decode first partition */ | |
2854 mb_num=0; | |
290 | 2855 s->first_slice_line=1; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2856 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
|
2857 ff_init_block_index(s); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2858 for(; s->mb_x<s->mb_width; s->mb_x++){ |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
2859 const int xy= s->mb_x + s->mb_y*s->mb_stride; |
453 | 2860 int cbpc; |
2861 int dir=0; | |
2862 | |
2863 mb_num++; | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2864 ff_update_block_index(s); |
453 | 2865 if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1) |
2866 s->first_slice_line=0; | |
2867 | |
2868 if(s->pict_type==I_TYPE){ | |
2869 int i; | |
2870 | |
1257 | 2871 if(show_bits_long(&s->gb, 19)==DC_MARKER){ |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2872 return mb_num-1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2873 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2874 |
1482 | 2875 do{ |
2876 cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2); | |
2877 if (cbpc < 0){ | |
2878 fprintf(stderr, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y); | |
2879 return -1; | |
2880 } | |
2881 }while(cbpc == 8); | |
2882 | |
453 | 2883 s->cbp_table[xy]= cbpc & 3; |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
2884 s->current_picture.mb_type[xy]= MB_TYPE_INTRA; |
453 | 2885 s->mb_intra = 1; |
2886 | |
2887 if(cbpc & 4) { | |
698 | 2888 change_qscale(s, quant_tab[get_bits(&s->gb, 2)]); |
453 | 2889 } |
903 | 2890 s->current_picture.qscale_table[xy]= s->qscale; |
453 | 2891 |
2892 s->mbintra_table[xy]= 1; | |
2893 for(i=0; i<6; i++){ | |
2894 int dc_pred_dir; | |
2895 int dc= mpeg4_decode_dc(s, i, &dc_pred_dir); | |
2896 if(dc < 0){ | |
2897 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
|
2898 return -1; |
453 | 2899 } |
2900 dir<<=1; | |
2901 if(dc_pred_dir) dir|=1; | |
2902 } | |
2903 s->pred_dir_table[xy]= dir; | |
2904 }else{ /* P/S_TYPE */ | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2905 int mx, my, pred_x, pred_y, bits; |
1064 | 2906 int16_t * const mot_val= s->motion_val[s->block_index[0]]; |
453 | 2907 const int stride= s->block_wrap[0]*2; |
2908 | |
1483 | 2909 // do{ //FIXME |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2910 bits= show_bits(&s->gb, 17); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2911 if(bits==MOTION_MARKER){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2912 return mb_num-1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2913 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2914 skip_bits1(&s->gb); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2915 if(bits&0x10000){ |
453 | 2916 /* skip mb */ |
2917 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){ | |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
2918 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0; |
753 | 2919 mx= get_amv(s, 0); |
2920 my= get_amv(s, 1); | |
453 | 2921 }else{ |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
2922 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0; |
753 | 2923 mx=my=0; |
453 | 2924 } |
2925 mot_val[0 ]= mot_val[2 ]= | |
2926 mot_val[0+stride]= mot_val[2+stride]= mx; | |
2927 mot_val[1 ]= mot_val[3 ]= | |
2928 mot_val[1+stride]= mot_val[3+stride]= my; | |
2929 | |
2930 if(s->mbintra_table[xy]) | |
2931 ff_clean_intra_table_entries(s); | |
2932 continue; | |
2933 } | |
1482 | 2934 |
544 | 2935 cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2); |
453 | 2936 if (cbpc < 0){ |
2937 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
|
2938 return -1; |
453 | 2939 } |
1483 | 2940 // }while(cbpc == 20); |
1482 | 2941 |
453 | 2942 s->cbp_table[xy]= cbpc&(8+3); //8 is dquant |
2943 | |
2944 s->mb_intra = ((cbpc & 4) != 0); | |
2945 | |
2946 if(s->mb_intra){ | |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
2947 s->current_picture.mb_type[xy]= MB_TYPE_INTRA; |
453 | 2948 s->mbintra_table[xy]= 1; |
2949 mot_val[0 ]= mot_val[2 ]= | |
2950 mot_val[0+stride]= mot_val[2+stride]= 0; | |
2951 mot_val[1 ]= mot_val[3 ]= | |
2952 mot_val[1+stride]= mot_val[3+stride]= 0; | |
2953 }else{ | |
2954 if(s->mbintra_table[xy]) | |
2955 ff_clean_intra_table_entries(s); | |
2956 | |
2957 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0) | |
2958 s->mcsel= get_bits1(&s->gb); | |
2959 else s->mcsel= 0; | |
2960 | |
2961 if ((cbpc & 16) == 0) { | |
2962 /* 16x16 motion prediction */ | |
2963 | |
2964 h263_pred_motion(s, 0, &pred_x, &pred_y); | |
753 | 2965 if(!s->mcsel){ |
2966 mx = h263_decode_motion(s, pred_x, s->f_code); | |
2967 if (mx >= 0xffff) | |
2968 return -1; | |
2969 | |
2970 my = h263_decode_motion(s, pred_y, s->f_code); | |
2971 if (my >= 0xffff) | |
2972 return -1; | |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
2973 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0; |
753 | 2974 } else { |
2975 mx = get_amv(s, 0); | |
2976 my = get_amv(s, 1); | |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
2977 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0; |
453 | 2978 } |
753 | 2979 |
453 | 2980 mot_val[0 ]= mot_val[2 ] = |
2981 mot_val[0+stride]= mot_val[2+stride]= mx; | |
2982 mot_val[1 ]= mot_val[3 ]= | |
2983 mot_val[1+stride]= mot_val[3+stride]= my; | |
2984 } else { | |
2985 int i; | |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
2986 s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0; |
453 | 2987 for(i=0;i<4;i++) { |
1064 | 2988 int16_t *mot_val= h263_pred_motion(s, i, &pred_x, &pred_y); |
453 | 2989 mx = h263_decode_motion(s, pred_x, s->f_code); |
2990 if (mx >= 0xffff) | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2991 return -1; |
453 | 2992 |
2993 my = h263_decode_motion(s, pred_y, s->f_code); | |
2994 if (my >= 0xffff) | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2995 return -1; |
453 | 2996 mot_val[0] = mx; |
2997 mot_val[1] = my; | |
2998 } | |
2999 } | |
3000 } | |
3001 } | |
3002 } | |
3003 s->mb_x= 0; | |
3004 } | |
3005 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3006 return mb_num; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3007 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3008 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3009 /** |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3010 * decode second partition. |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3011 * @return <0 if an error occured |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3012 */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3013 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
|
3014 int mb_num=0; |
1064 | 3015 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
|
3016 |
453 | 3017 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
|
3018 s->first_slice_line=1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3019 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
|
3020 ff_init_block_index(s); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3021 for(; mb_num < mb_count && s->mb_x<s->mb_width; s->mb_x++){ |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3022 const int xy= s->mb_x + s->mb_y*s->mb_stride; |
453 | 3023 |
3024 mb_num++; | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3025 ff_update_block_index(s); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3026 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
|
3027 s->first_slice_line=0; |
453 | 3028 |
3029 if(s->pict_type==I_TYPE){ | |
3030 int ac_pred= get_bits1(&s->gb); | |
544 | 3031 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1); |
453 | 3032 if(cbpy<0){ |
3033 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
|
3034 return -1; |
453 | 3035 } |
3036 | |
3037 s->cbp_table[xy]|= cbpy<<2; | |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3038 s->current_picture.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED; |
453 | 3039 }else{ /* P || S_TYPE */ |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3040 if(IS_INTRA(s->current_picture.mb_type[xy])){ |
453 | 3041 int dir=0,i; |
3042 int ac_pred = get_bits1(&s->gb); | |
544 | 3043 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1); |
453 | 3044 |
3045 if(cbpy<0){ | |
3046 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
|
3047 return -1; |
453 | 3048 } |
3049 | |
3050 if(s->cbp_table[xy] & 8) { | |
698 | 3051 change_qscale(s, quant_tab[get_bits(&s->gb, 2)]); |
453 | 3052 } |
903 | 3053 s->current_picture.qscale_table[xy]= s->qscale; |
453 | 3054 |
3055 for(i=0; i<6; i++){ | |
3056 int dc_pred_dir; | |
3057 int dc= mpeg4_decode_dc(s, i, &dc_pred_dir); | |
3058 if(dc < 0){ | |
3059 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
|
3060 return -1; |
453 | 3061 } |
3062 dir<<=1; | |
3063 if(dc_pred_dir) dir|=1; | |
3064 } | |
3065 s->cbp_table[xy]&= 3; //remove dquant | |
3066 s->cbp_table[xy]|= cbpy<<2; | |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3067 s->current_picture.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3068 s->pred_dir_table[xy]= dir; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3069 }else if(IS_SKIP(s->current_picture.mb_type[xy])){ |
903 | 3070 s->current_picture.qscale_table[xy]= s->qscale; |
453 | 3071 s->cbp_table[xy]= 0; |
3072 }else{ | |
544 | 3073 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1); |
453 | 3074 |
3075 if(cbpy<0){ | |
3076 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
|
3077 return -1; |
453 | 3078 } |
3079 | |
3080 if(s->cbp_table[xy] & 8) { | |
698 | 3081 change_qscale(s, quant_tab[get_bits(&s->gb, 2)]); |
453 | 3082 } |
903 | 3083 s->current_picture.qscale_table[xy]= s->qscale; |
453 | 3084 |
3085 s->cbp_table[xy]&= 3; //remove dquant | |
3086 s->cbp_table[xy]|= (cbpy^0xf)<<2; | |
3087 } | |
3088 } | |
3089 } | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3090 if(mb_num >= mb_count) return 0; |
453 | 3091 s->mb_x= 0; |
3092 } | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3093 return 0; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3094 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3095 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3096 /** |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3097 * decodes the first & second partition |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3098 * @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
|
3099 */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3100 int ff_mpeg4_decode_partitions(MpegEncContext *s) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3101 { |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3102 int mb_num; |
1144 | 3103 const int part_a_error= s->pict_type==I_TYPE ? (DC_ERROR|MV_ERROR) : MV_ERROR; |
3104 const int part_a_end = s->pict_type==I_TYPE ? (DC_END |MV_END) : MV_END; | |
453 | 3105 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3106 mb_num= mpeg4_decode_partition_a(s); |
1144 | 3107 if(mb_num<0){ |
3108 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
|
3109 return -1; |
1144 | 3110 } |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3111 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3112 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
|
3113 fprintf(stderr, "slice below monitor ...\n"); |
1144 | 3114 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
|
3115 return -1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3116 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3117 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3118 s->mb_num_left= mb_num; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3119 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3120 if(s->pict_type==I_TYPE){ |
1257 | 3121 if(get_bits_long(&s->gb, 19)!=DC_MARKER){ |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3122 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
|
3123 return -1; |
1144 | 3124 } |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3125 }else{ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3126 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
|
3127 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
|
3128 return -1; |
1144 | 3129 } |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3130 } |
1144 | 3131 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
|
3132 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3133 if( mpeg4_decode_partition_b(s, mb_num) < 0){ |
1144 | 3134 if(s->pict_type==P_TYPE) |
3135 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
|
3136 return -1; |
1144 | 3137 }else{ |
3138 if(s->pict_type==P_TYPE) | |
3139 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
|
3140 } |
453 | 3141 |
3142 return 0; | |
3143 } | |
3144 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3145 /** |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3146 * decode partition C of one MB. |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3147 * @return <0 if an error occured |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3148 */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3149 static int mpeg4_decode_partitioned_mb(MpegEncContext *s, DCTELEM block[6][64]) |
453 | 3150 { |
3151 int cbp, mb_type; | |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3152 const int xy= s->mb_x + s->mb_y*s->mb_stride; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3153 |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3154 mb_type= s->current_picture.mb_type[xy]; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3155 cbp = s->cbp_table[xy]; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3156 |
903 | 3157 if(s->current_picture.qscale_table[xy] != s->qscale){ |
3158 s->qscale= s->current_picture.qscale_table[xy]; | |
698 | 3159 s->y_dc_scale= s->y_dc_scale_table[ s->qscale ]; |
3160 s->c_dc_scale= s->c_dc_scale_table[ s->qscale ]; | |
453 | 3161 } |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3162 |
453 | 3163 if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) { |
3164 int i; | |
3165 for(i=0; i<4; i++){ | |
3166 s->mv[0][i][0] = s->motion_val[ s->block_index[i] ][0]; | |
3167 s->mv[0][i][1] = s->motion_val[ s->block_index[i] ][1]; | |
3168 } | |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3169 s->mb_intra = IS_INTRA(mb_type); |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3170 |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3171 if (IS_SKIP(mb_type)) { |
453 | 3172 /* skip mb */ |
3173 for(i=0;i<6;i++) | |
3174 s->block_last_index[i] = -1; | |
3175 s->mv_dir = MV_DIR_FORWARD; | |
3176 s->mv_type = MV_TYPE_16X16; | |
3177 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){ | |
3178 s->mcsel=1; | |
3179 s->mb_skiped = 0; | |
3180 }else{ | |
3181 s->mcsel=0; | |
3182 s->mb_skiped = 1; | |
3183 } | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3184 }else if(s->mb_intra){ |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3185 s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]); |
453 | 3186 }else if(!s->mb_intra){ |
3187 // s->mcsel= 0; //FIXME do we need to init that | |
3188 | |
3189 s->mv_dir = MV_DIR_FORWARD; | |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3190 if (IS_8X8(mb_type)) { |
453 | 3191 s->mv_type = MV_TYPE_8X8; |
3192 } else { | |
3193 s->mv_type = MV_TYPE_16X16; | |
3194 } | |
3195 } | |
3196 } else { /* I-Frame */ | |
3197 s->mb_intra = 1; | |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3198 s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]); |
1132 | 3199 } |
3200 | |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3201 if (!IS_SKIP(mb_type)) { |
1132 | 3202 int i; |
453 | 3203 /* decode each block */ |
3204 for (i = 0; i < 6; i++) { | |
1132 | 3205 if(mpeg4_decode_block(s, block[i], i, cbp&32, s->mb_intra, s->rvlc) < 0){ |
3206 fprintf(stderr, "texture corrupted at %d %d %d\n", s->mb_x, s->mb_y, s->mb_intra); | |
453 | 3207 return -1; |
3208 } | |
718 | 3209 cbp+=cbp; |
453 | 3210 } |
3211 } | |
290 | 3212 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3213 /* per-MB end of slice check */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3214 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3215 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
|
3216 //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
|
3217 if(mpeg4_is_resync(s)) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3218 return SLICE_END; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3219 else |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3220 return SLICE_NOEND; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3221 }else{ |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3222 if(mpeg4_is_resync(s)){ |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3223 const int delta= s->mb_x + 1 == s->mb_width ? 2 : 1; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3224 if(s->cbp_table[xy+delta]) |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3225 return SLICE_END; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3226 } |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3227 return SLICE_OK; |
619
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3228 } |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3229 } |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3230 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3231 int ff_h263_decode_mb(MpegEncContext *s, |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3232 DCTELEM block[6][64]) |
0 | 3233 { |
3234 int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant; | |
1064 | 3235 int16_t *mot_val; |
3236 static int8_t quant_tab[4] = { -1, -2, 1, 2 }; | |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3237 const int xy= s->mb_x + s->mb_y * s->mb_stride; |
359 | 3238 |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
3239 if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) { |
1482 | 3240 do{ |
21 | 3241 if (get_bits1(&s->gb)) { |
0 | 3242 /* skip mb */ |
3243 s->mb_intra = 0; | |
3244 for(i=0;i<6;i++) | |
3245 s->block_last_index[i] = -1; | |
3246 s->mv_dir = MV_DIR_FORWARD; | |
3247 s->mv_type = MV_TYPE_16X16; | |
255 | 3248 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){ |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3249 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_GMC | MB_TYPE_16x16 | MB_TYPE_L0; |
255 | 3250 s->mcsel=1; |
753 | 3251 s->mv[0][0][0]= get_amv(s, 0); |
3252 s->mv[0][0][1]= get_amv(s, 1); | |
255 | 3253 |
3254 s->mb_skiped = 0; | |
3255 }else{ | |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3256 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0; |
255 | 3257 s->mcsel=0; |
3258 s->mv[0][0][0] = 0; | |
3259 s->mv[0][0][1] = 0; | |
3260 s->mb_skiped = 1; | |
3261 } | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3262 goto end; |
0 | 3263 } |
544 | 3264 cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2); |
144 | 3265 //fprintf(stderr, "\tCBPC: %d", cbpc); |
1482 | 3266 if (cbpc < 0){ |
3267 fprintf(stderr, "cbpc damaged at %d %d\n", s->mb_x, s->mb_y); | |
0 | 3268 return -1; |
1482 | 3269 } |
3270 }while(cbpc == 20); | |
144 | 3271 |
0 | 3272 dquant = cbpc & 8; |
3273 s->mb_intra = ((cbpc & 4) != 0); | |
262 | 3274 if (s->mb_intra) goto intra; |
3275 | |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
3276 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
|
3277 s->mcsel= get_bits1(&s->gb); |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
3278 else s->mcsel= 0; |
544 | 3279 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1); |
0 | 3280 cbp = (cbpc & 3) | ((cbpy ^ 0xf) << 2); |
3281 if (dquant) { | |
698 | 3282 change_qscale(s, quant_tab[get_bits(&s->gb, 2)]); |
0 | 3283 } |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3284 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
|
3285 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
|
3286 |
0 | 3287 s->mv_dir = MV_DIR_FORWARD; |
3288 if ((cbpc & 16) == 0) { | |
619
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3289 if(s->mcsel){ |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3290 s->current_picture.mb_type[xy]= MB_TYPE_GMC | MB_TYPE_16x16 | MB_TYPE_L0; |
619
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3291 /* 16x16 global motion prediction */ |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3292 s->mv_type = MV_TYPE_16X16; |
753 | 3293 mx= get_amv(s, 0); |
3294 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
|
3295 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
|
3296 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
|
3297 }else if((!s->progressive_sequence) && get_bits1(&s->gb)){ |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3298 s->current_picture.mb_type[xy]= MB_TYPE_16x8 | MB_TYPE_L0 | MB_TYPE_INTERLACED; |
619
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3299 /* 16x8 field motion prediction */ |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3300 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
|
3301 |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3302 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
|
3303 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
|
3304 |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3305 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
|
3306 |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3307 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
|
3308 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
|
3309 if (mx >= 0xffff) |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3310 return -1; |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3311 |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3312 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
|
3313 if (my >= 0xffff) |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3314 return -1; |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3315 |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3316 s->mv[0][i][0] = mx; |
661 | 3317 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
|
3318 } |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3319 }else{ |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3320 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0; |
619
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3321 /* 16x16 motion prediction */ |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3322 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
|
3323 h263_pred_motion(s, 0, &pred_x, &pred_y); |
1089 | 3324 if (s->umvplus) |
619
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3325 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
|
3326 else |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3327 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
|
3328 |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3329 if (mx >= 0xffff) |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3330 return -1; |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3331 |
1089 | 3332 if (s->umvplus) |
619
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3333 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
|
3334 else |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3335 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
|
3336 |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3337 if (my >= 0xffff) |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3338 return -1; |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3339 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
|
3340 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
|
3341 |
1089 | 3342 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
|
3343 skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */ |
255 | 3344 } |
0 | 3345 } else { |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3346 s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0; |
0 | 3347 s->mv_type = MV_TYPE_8X8; |
3348 for(i=0;i<4;i++) { | |
3349 mot_val = h263_pred_motion(s, i, &pred_x, &pred_y); | |
1089 | 3350 if (s->umvplus) |
78 | 3351 mx = h263p_decode_umotion(s, pred_x); |
3352 else | |
262 | 3353 mx = h263_decode_motion(s, pred_x, s->f_code); |
0 | 3354 if (mx >= 0xffff) |
3355 return -1; | |
78 | 3356 |
1089 | 3357 if (s->umvplus) |
78 | 3358 my = h263p_decode_umotion(s, pred_y); |
3359 else | |
262 | 3360 my = h263_decode_motion(s, pred_y, s->f_code); |
0 | 3361 if (my >= 0xffff) |
3362 return -1; | |
3363 s->mv[0][i][0] = mx; | |
3364 s->mv[0][i][1] = my; | |
1089 | 3365 if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1) |
78 | 3366 skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */ |
0 | 3367 mot_val[0] = mx; |
3368 mot_val[1] = my; | |
3369 } | |
3370 } | |
262 | 3371 } else if(s->pict_type==B_TYPE) { |
3372 int modb1; // first bit of modb | |
3373 int modb2; // second bit of modb | |
3374 int mb_type; | |
3375 | |
3376 s->mb_intra = 0; //B-frames never contain intra blocks | |
3377 s->mcsel=0; // ... true gmc blocks | |
3378 | |
3379 if(s->mb_x==0){ | |
674 | 3380 for(i=0; i<2; i++){ |
3381 s->last_mv[i][0][0]= | |
3382 s->last_mv[i][0][1]= | |
3383 s->last_mv[i][1][0]= | |
3384 s->last_mv[i][1][1]= 0; | |
3385 } | |
262 | 3386 } |
3387 | |
3388 /* if we skipped it in the future P Frame than skip it now too */ | |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3389 s->mb_skiped= s->next_picture.mbskip_table[s->mb_y * s->mb_stride + s->mb_x]; // Note, skiptab=0 if last was GMC |
262 | 3390 |
3391 if(s->mb_skiped){ | |
3392 /* skip mb */ | |
3393 for(i=0;i<6;i++) | |
3394 s->block_last_index[i] = -1; | |
3395 | |
3396 s->mv_dir = MV_DIR_FORWARD; | |
3397 s->mv_type = MV_TYPE_16X16; | |
3398 s->mv[0][0][0] = 0; | |
3399 s->mv[0][0][1] = 0; | |
3400 s->mv[1][0][0] = 0; | |
3401 s->mv[1][0][1] = 0; | |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3402 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3403 goto end; |
262 | 3404 } |
3405 | |
666 | 3406 modb1= get_bits1(&s->gb); |
3407 if(modb1){ | |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3408 mb_type= MB_TYPE_DIRECT2 | MB_TYPE_SKIP | MB_TYPE_L0L1; //like MB_TYPE_B_DIRECT but no vectors coded |
666 | 3409 cbp=0; |
3410 }else{ | |
262 | 3411 modb2= get_bits1(&s->gb); |
544 | 3412 mb_type= get_vlc2(&s->gb, mb_type_b_vlc.table, MB_TYPE_B_VLC_BITS, 1); |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3413 if(mb_type<0){ |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3414 printf("illegal MB_type\n"); |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3415 return -1; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3416 } |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3417 mb_type= mb_type_b_map[ mb_type ]; |
666 | 3418 if(modb2) cbp= 0; |
3419 else cbp= get_bits(&s->gb, 6); | |
3420 | |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3421 if ((!IS_DIRECT(mb_type)) && cbp) { |
262 | 3422 if(get_bits1(&s->gb)){ |
698 | 3423 change_qscale(s, get_bits1(&s->gb)*4 - 2); |
262 | 3424 } |
3425 } | |
664 | 3426 |
3427 if(!s->progressive_sequence){ | |
3428 if(cbp) | |
3429 s->interlaced_dct= get_bits1(&s->gb); | |
3430 | |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3431 if(!IS_DIRECT(mb_type) && get_bits1(&s->gb)){ |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3432 mb_type |= MB_TYPE_16x8 | MB_TYPE_INTERLACED; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3433 mb_type &= ~MB_TYPE_16x16; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3434 |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3435 if(USES_LIST(mb_type, 0)){ |
667 | 3436 s->field_select[0][0]= get_bits1(&s->gb); |
3437 s->field_select[0][1]= get_bits1(&s->gb); | |
3438 } | |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3439 if(USES_LIST(mb_type, 1)){ |
667 | 3440 s->field_select[1][0]= get_bits1(&s->gb); |
3441 s->field_select[1][1]= get_bits1(&s->gb); | |
3442 } | |
3443 } | |
666 | 3444 } |
3445 | |
667 | 3446 s->mv_dir = 0; |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3447 if((mb_type & (MB_TYPE_DIRECT2|MB_TYPE_INTERLACED)) == 0){ |
666 | 3448 s->mv_type= MV_TYPE_16X16; |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3449 |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3450 if(USES_LIST(mb_type, 0)){ |
666 | 3451 s->mv_dir = MV_DIR_FORWARD; |
3452 | |
3453 mx = h263_decode_motion(s, s->last_mv[0][0][0], s->f_code); | |
3454 my = h263_decode_motion(s, s->last_mv[0][0][1], s->f_code); | |
3455 s->last_mv[0][1][0]= s->last_mv[0][0][0]= s->mv[0][0][0] = mx; | |
3456 s->last_mv[0][1][1]= s->last_mv[0][0][1]= s->mv[0][0][1] = my; | |
667 | 3457 } |
666 | 3458 |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3459 if(USES_LIST(mb_type, 1)){ |
666 | 3460 s->mv_dir |= MV_DIR_BACKWARD; |
3461 | |
3462 mx = h263_decode_motion(s, s->last_mv[1][0][0], s->b_code); | |
3463 my = h263_decode_motion(s, s->last_mv[1][0][1], s->b_code); | |
3464 s->last_mv[1][1][0]= s->last_mv[1][0][0]= s->mv[1][0][0] = mx; | |
3465 s->last_mv[1][1][1]= s->last_mv[1][0][1]= s->mv[1][0][1] = my; | |
3466 } | |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3467 }else if(!IS_DIRECT(mb_type)){ |
666 | 3468 s->mv_type= MV_TYPE_FIELD; |
667 | 3469 |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3470 if(USES_LIST(mb_type, 0)){ |
666 | 3471 s->mv_dir = MV_DIR_FORWARD; |
3472 | |
3473 for(i=0; i<2; i++){ | |
3474 mx = h263_decode_motion(s, s->last_mv[0][i][0] , s->f_code); | |
3475 my = h263_decode_motion(s, s->last_mv[0][i][1]/2, s->f_code); | |
3476 s->last_mv[0][i][0]= s->mv[0][i][0] = mx; | |
3477 s->last_mv[0][i][1]= (s->mv[0][i][1] = my)*2; | |
3478 } | |
667 | 3479 } |
666 | 3480 |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3481 if(USES_LIST(mb_type, 1)){ |
666 | 3482 s->mv_dir |= MV_DIR_BACKWARD; |
3483 | |
3484 for(i=0; i<2; i++){ | |
3485 mx = h263_decode_motion(s, s->last_mv[1][i][0] , s->b_code); | |
3486 my = h263_decode_motion(s, s->last_mv[1][i][1]/2, s->b_code); | |
3487 s->last_mv[1][i][0]= s->mv[1][i][0] = mx; | |
3488 s->last_mv[1][i][1]= (s->mv[1][i][1] = my)*2; | |
664 | 3489 } |
3490 } | |
3491 } | |
3492 } | |
666 | 3493 |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3494 if(IS_DIRECT(mb_type)){ |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3495 if(IS_SKIP(mb_type)) |
666 | 3496 mx=my=0; |
3497 else{ | |
3498 mx = h263_decode_motion(s, 0, 1); | |
3499 my = h263_decode_motion(s, 0, 1); | |
3500 } | |
664 | 3501 |
262 | 3502 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT; |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3503 mb_type |= ff_mpeg4_set_direct_mv(s, mx, my); |
664 | 3504 } |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3505 s->current_picture.mb_type[xy]= mb_type; |
262 | 3506 } else { /* I-Frame */ |
1482 | 3507 do{ |
3508 cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2); | |
3509 if (cbpc < 0){ | |
3510 fprintf(stderr, "I cbpc damaged at %d %d\n", s->mb_x, s->mb_y); | |
3511 return -1; | |
3512 } | |
3513 }while(cbpc == 8); | |
3514 | |
262 | 3515 dquant = cbpc & 4; |
3516 s->mb_intra = 1; | |
3517 intra: | |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3518 s->current_picture.mb_type[xy]= MB_TYPE_INTRA; |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
3519 if (s->h263_pred || s->h263_aic) { |
21 | 3520 s->ac_pred = get_bits1(&s->gb); |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3521 if(s->ac_pred){ |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3522 s->current_picture.mb_type[xy]= MB_TYPE_INTRA | MB_TYPE_ACPRED; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3523 |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3524 if (s->h263_aic) |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3525 s->h263_aic_dir = get_bits1(&s->gb); |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3526 } |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3527 }else |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3528 s->ac_pred = 0; |
591 | 3529 |
544 | 3530 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1); |
1482 | 3531 if(cbpy<0){ |
3532 fprintf(stderr, "I cbpy damaged at %d %d\n", s->mb_x, s->mb_y); | |
3533 return -1; | |
3534 } | |
0 | 3535 cbp = (cbpc & 3) | (cbpy << 2); |
3536 if (dquant) { | |
698 | 3537 change_qscale(s, quant_tab[get_bits(&s->gb, 2)]); |
0 | 3538 } |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3539 |
619
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3540 if(!s->progressive_sequence) |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3541 s->interlaced_dct= get_bits1(&s->gb); |
575 | 3542 |
3543 /* decode each block */ | |
3544 if (s->h263_pred) { | |
3545 for (i = 0; i < 6; i++) { | |
1132 | 3546 if (mpeg4_decode_block(s, block[i], i, cbp&32, 1, 0) < 0) |
575 | 3547 return -1; |
718 | 3548 cbp+=cbp; |
575 | 3549 } |
3550 } else { | |
3551 for (i = 0; i < 6; i++) { | |
718 | 3552 if (h263_decode_block(s, block[i], i, cbp&32) < 0) |
575 | 3553 return -1; |
718 | 3554 cbp+=cbp; |
575 | 3555 } |
3556 } | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3557 goto end; |
0 | 3558 } |
3559 | |
3560 /* decode each block */ | |
3561 if (s->h263_pred) { | |
575 | 3562 for (i = 0; i < 6; i++) { |
1132 | 3563 if (mpeg4_decode_block(s, block[i], i, cbp&32, 0, 0) < 0) |
0 | 3564 return -1; |
718 | 3565 cbp+=cbp; |
575 | 3566 } |
0 | 3567 } else { |
575 | 3568 for (i = 0; i < 6; i++) { |
718 | 3569 if (h263_decode_block(s, block[i], i, cbp&32) < 0) |
0 | 3570 return -1; |
718 | 3571 cbp+=cbp; |
575 | 3572 } |
0 | 3573 } |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3574 end: |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3575 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3576 /* per-MB end of slice check */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3577 if(s->codec_id==CODEC_ID_MPEG4){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3578 if(mpeg4_is_resync(s)){ |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3579 const int delta= s->mb_x + 1 == s->mb_width ? 2 : 1; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3580 if(s->pict_type==B_TYPE && s->next_picture.mbskip_table[xy + delta]) |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3581 return SLICE_OK; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3582 return SLICE_END; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3583 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3584 }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
|
3585 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
|
3586 |
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
|
3587 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
|
3588 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
|
3589 } |
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
|
3590 |
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
|
3591 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
|
3592 return SLICE_END; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3593 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3594 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3595 return SLICE_OK; |
0 | 3596 } |
3597 | |
262 | 3598 static int h263_decode_motion(MpegEncContext * s, int pred, int f_code) |
0 | 3599 { |
656
e47fa3e3f2d5
statistics for forw & back p-MBs instead of just one counter for both
michaelni
parents:
654
diff
changeset
|
3600 int code, val, sign, shift, l; |
544 | 3601 code = get_vlc2(&s->gb, mv_vlc.table, MV_VLC_BITS, 2); |
0 | 3602 |
3603 if (code == 0) | |
3604 return pred; | |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3605 if (code < 0) |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3606 return 0xffff; |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
702
diff
changeset
|
3607 |
21 | 3608 sign = get_bits1(&s->gb); |
262 | 3609 shift = f_code - 1; |
1255
625ccacd1113
decode motion & modulo optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1254
diff
changeset
|
3610 val = code; |
625ccacd1113
decode motion & modulo optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1254
diff
changeset
|
3611 if (shift) { |
625ccacd1113
decode motion & modulo optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1254
diff
changeset
|
3612 val = (val - 1) << shift; |
0 | 3613 val |= get_bits(&s->gb, shift); |
1255
625ccacd1113
decode motion & modulo optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1254
diff
changeset
|
3614 val++; |
625ccacd1113
decode motion & modulo optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1254
diff
changeset
|
3615 } |
0 | 3616 if (sign) |
3617 val = -val; | |
3618 val += pred; | |
475 | 3619 |
0 | 3620 /* modulo decoding */ |
3621 if (!s->h263_long_vectors) { | |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
702
diff
changeset
|
3622 l = 1 << (f_code + 4); |
1255
625ccacd1113
decode motion & modulo optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1254
diff
changeset
|
3623 val = ((val + l)&(l*2-1)) - l; |
0 | 3624 } else { |
3625 /* horrible h263 long vector mode */ | |
3626 if (pred < -31 && val < -63) | |
3627 val += 64; | |
3628 if (pred > 32 && val > 63) | |
3629 val -= 64; | |
154
f914f710b8d0
- Fixed a bug on H.263 MV prediction for MB on GOBs limits.
pulento
parents:
144
diff
changeset
|
3630 |
0 | 3631 } |
3632 return val; | |
3633 } | |
3634 | |
78 | 3635 /* Decodes RVLC of H.263+ UMV */ |
3636 static int h263p_decode_umotion(MpegEncContext * s, int pred) | |
3637 { | |
3638 int code = 0, sign; | |
3639 | |
3640 if (get_bits1(&s->gb)) /* Motion difference = 0 */ | |
3641 return pred; | |
3642 | |
3643 code = 2 + get_bits1(&s->gb); | |
3644 | |
3645 while (get_bits1(&s->gb)) | |
3646 { | |
3647 code <<= 1; | |
3648 code += get_bits1(&s->gb); | |
3649 } | |
3650 sign = code & 1; | |
3651 code >>= 1; | |
3652 | |
3653 code = (sign) ? (pred - code) : (pred + code); | |
3654 #ifdef DEBUG | |
3655 fprintf(stderr,"H.263+ UMV Motion = %d\n", code); | |
3656 #endif | |
3657 return code; | |
3658 | |
3659 } | |
3660 | |
0 | 3661 static int h263_decode_block(MpegEncContext * s, DCTELEM * block, |
3662 int n, int coded) | |
3663 { | |
3664 int code, level, i, j, last, run; | |
3665 RLTable *rl = &rl_inter; | |
1064 | 3666 const uint8_t *scan_table; |
0 | 3667 |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
702
diff
changeset
|
3668 scan_table = s->intra_scantable.permutated; |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
3669 if (s->h263_aic && s->mb_intra) { |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
3670 rl = &rl_intra_aic; |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
3671 i = 0; |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
3672 if (s->ac_pred) { |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
3673 if (s->h263_aic_dir) |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
702
diff
changeset
|
3674 scan_table = s->intra_v_scantable.permutated; /* left */ |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
3675 else |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
702
diff
changeset
|
3676 scan_table = s->intra_h_scantable.permutated; /* top */ |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
3677 } |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
3678 } else if (s->mb_intra) { |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
3679 /* DC coef */ |
1090 | 3680 if(s->h263_rv10){ |
3681 if (s->rv10_version == 3 && s->pict_type == I_TYPE) { | |
0 | 3682 int component, diff; |
3683 component = (n <= 3 ? 0 : n - 4 + 1); | |
3684 level = s->last_dc[component]; | |
3685 if (s->rv10_first_dc_coded[component]) { | |
3686 diff = rv_decode_dc(s, n); | |
3687 if (diff == 0xffff) | |
3688 return -1; | |
3689 level += diff; | |
3690 level = level & 0xff; /* handle wrap round */ | |
3691 s->last_dc[component] = level; | |
3692 } else { | |
3693 s->rv10_first_dc_coded[component] = 1; | |
3694 } | |
1090 | 3695 } else { |
3696 level = get_bits(&s->gb, 8); | |
3697 } | |
3698 }else{ | |
0 | 3699 level = get_bits(&s->gb, 8); |
1089 | 3700 if((level&0x7F) == 0){ |
1090 | 3701 fprintf(stderr, "illegal dc %d at %d %d\n", level, s->mb_x, s->mb_y); |
1089 | 3702 return -1; |
3703 } | |
0 | 3704 if (level == 255) |
3705 level = 128; | |
3706 } | |
3707 block[0] = level; | |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
3708 i = 1; |
0 | 3709 } else { |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
3710 i = 0; |
0 | 3711 } |
3712 if (!coded) { | |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
3713 if (s->mb_intra && s->h263_aic) |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
3714 goto not_coded; |
0 | 3715 s->block_last_index[n] = i - 1; |
3716 return 0; | |
3717 } | |
3718 | |
3719 for(;;) { | |
544 | 3720 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
|
3721 if (code < 0){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3722 fprintf(stderr, "illegal ac vlc code at %dx%d\n", s->mb_x, s->mb_y); |
0 | 3723 return -1; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3724 } |
0 | 3725 if (code == rl->n) { |
3726 /* escape */ | |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
3727 if (s->h263_flv > 1) { |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
3728 int is11 = get_bits1(&s->gb); |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
3729 last = get_bits1(&s->gb); |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
3730 run = get_bits(&s->gb, 6); |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
3731 if(is11){ |
1356 | 3732 level = get_sbits(&s->gb, 11); |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
3733 } else { |
1356 | 3734 level = get_sbits(&s->gb, 7); |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
3735 } |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
3736 } else { |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
3737 last = get_bits1(&s->gb); |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
3738 run = get_bits(&s->gb, 6); |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
3739 level = (int8_t)get_bits(&s->gb, 8); |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
3740 if(level == -128){ |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
3741 if (s->h263_rv10) { |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
3742 /* XXX: should patch encoder too */ |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
3743 level = get_sbits(&s->gb, 12); |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
3744 }else{ |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
3745 level = get_bits(&s->gb, 5); |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
3746 level |= get_sbits(&s->gb, 6)<<5; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
3747 } |
1089 | 3748 } |
0 | 3749 } |
3750 } else { | |
3751 run = rl->table_run[code]; | |
3752 level = rl->table_level[code]; | |
3753 last = code >= rl->last; | |
21 | 3754 if (get_bits1(&s->gb)) |
0 | 3755 level = -level; |
3756 } | |
3757 i += run; | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3758 if (i >= 64){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3759 fprintf(stderr, "run overflow at %dx%d\n", s->mb_x, s->mb_y); |
0 | 3760 return -1; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3761 } |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
3762 j = scan_table[i]; |
0 | 3763 block[j] = level; |
3764 if (last) | |
3765 break; | |
3766 i++; | |
3767 } | |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
3768 not_coded: |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
3769 if (s->mb_intra && s->h263_aic) { |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
3770 h263_pred_acdc(s, block, n); |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
3771 i = 63; |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
3772 } |
0 | 3773 s->block_last_index[n] = i; |
3774 return 0; | |
3775 } | |
3776 | |
1034 | 3777 /** |
3778 * decodes the dc value. | |
3779 * @param n block index (0-3 are luma, 4-5 are chroma) | |
3780 * @param dir_ptr the prediction direction will be stored here | |
3781 * @return the quantized dc | |
3782 */ | |
453 | 3783 static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr) |
0 | 3784 { |
3785 int level, pred, code; | |
1064 | 3786 uint16_t *dc_val; |
0 | 3787 |
3788 if (n < 4) | |
544 | 3789 code = get_vlc2(&s->gb, dc_lum.table, DC_VLC_BITS, 1); |
0 | 3790 else |
544 | 3791 code = get_vlc2(&s->gb, dc_chrom.table, DC_VLC_BITS, 1); |
453 | 3792 if (code < 0 || code > 9 /* && s->nbit<9 */){ |
3793 fprintf(stderr, "illegal dc vlc\n"); | |
0 | 3794 return -1; |
453 | 3795 } |
0 | 3796 if (code == 0) { |
3797 level = 0; | |
3798 } else { | |
1271
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
3799 if(IS_3IV1){ |
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
3800 if(code==1) |
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
3801 level= 2*get_bits1(&s->gb)-1; |
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
3802 else{ |
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
3803 if(get_bits1(&s->gb)) |
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
3804 level = get_bits(&s->gb, code-1) + (1<<(code-1)); |
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
3805 else |
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
3806 level = -get_bits(&s->gb, code-1) - (1<<(code-1)); |
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
3807 } |
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
3808 }else{ |
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
3809 level = get_xbits(&s->gb, code); |
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
3810 } |
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
3811 |
453 | 3812 if (code > 8){ |
3813 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
|
3814 if(s->error_resilience>=2){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3815 fprintf(stderr, "dc marker bit missing\n"); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3816 return -1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3817 } |
453 | 3818 } |
3819 } | |
0 | 3820 } |
498 | 3821 pred = ff_mpeg4_pred_dc(s, n, &dc_val, dir_ptr); |
0 | 3822 level += pred; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3823 if (level < 0){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3824 if(s->error_resilience>=3){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3825 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
|
3826 return -1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3827 } |
0 | 3828 level = 0; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3829 } |
0 | 3830 if (n < 4) { |
3831 *dc_val = level * s->y_dc_scale; | |
3832 } else { | |
3833 *dc_val = level * s->c_dc_scale; | |
3834 } | |
1271
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
3835 if(IS_3IV1) |
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
3836 *dc_val = level * 8; |
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
3837 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3838 if(s->error_resilience>=3){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3839 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
|
3840 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
|
3841 return -1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3842 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3843 } |
0 | 3844 return level; |
3845 } | |
3846 | |
453 | 3847 /** |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3848 * decodes a block. |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3849 * @return <0 if an error occured |
453 | 3850 */ |
3851 static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block, | |
1132 | 3852 int n, int coded, int intra, int rvlc) |
0 | 3853 { |
549 | 3854 int level, i, last, run; |
0 | 3855 int dc_pred_dir; |
575 | 3856 RLTable * rl; |
3857 RL_VLC_ELEM * rl_vlc; | |
1064 | 3858 const uint8_t * scan_table; |
549 | 3859 int qmul, qadd; |
0 | 3860 |
1132 | 3861 //Note intra & rvlc should be optimized away if this is inlined |
3862 | |
575 | 3863 if(intra) { |
0 | 3864 /* DC coef */ |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3865 if(s->partitioned_frame){ |
453 | 3866 level = s->dc_val[0][ s->block_index[n] ]; |
1261
362947395f5c
fastdiv patch by (BERO <bero at geocities dot co dot jp>) with fixes & cleanup by me
michaelni
parents:
1257
diff
changeset
|
3867 if(n<4) level= FASTDIV((level + (s->y_dc_scale>>1)), s->y_dc_scale); |
362947395f5c
fastdiv patch by (BERO <bero at geocities dot co dot jp>) with fixes & cleanup by me
michaelni
parents:
1257
diff
changeset
|
3868 else level= FASTDIV((level + (s->c_dc_scale>>1)), s->c_dc_scale); |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3869 dc_pred_dir= (s->pred_dir_table[s->mb_x + s->mb_y*s->mb_stride]<<n)&32; |
453 | 3870 }else{ |
3871 level = mpeg4_decode_dc(s, n, &dc_pred_dir); | |
3872 if (level < 0) | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3873 return -1; |
453 | 3874 } |
0 | 3875 block[0] = level; |
549 | 3876 i = 0; |
0 | 3877 if (!coded) |
3878 goto not_coded; | |
1132 | 3879 |
3880 if(rvlc){ | |
3881 rl = &rvlc_rl_intra; | |
3882 rl_vlc = rvlc_rl_intra.rl_vlc[0]; | |
3883 }else{ | |
3884 rl = &rl_intra; | |
3885 rl_vlc = rl_intra.rl_vlc[0]; | |
3886 } | |
718 | 3887 if (s->ac_pred) { |
0 | 3888 if (dc_pred_dir == 0) |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
702
diff
changeset
|
3889 scan_table = s->intra_v_scantable.permutated; /* left */ |
0 | 3890 else |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
702
diff
changeset
|
3891 scan_table = s->intra_h_scantable.permutated; /* top */ |
0 | 3892 } else { |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
702
diff
changeset
|
3893 scan_table = s->intra_scantable.permutated; |
0 | 3894 } |
549 | 3895 qmul=1; |
3896 qadd=0; | |
0 | 3897 } else { |
549 | 3898 i = -1; |
0 | 3899 if (!coded) { |
549 | 3900 s->block_last_index[n] = i; |
0 | 3901 return 0; |
3902 } | |
1132 | 3903 if(rvlc) rl = &rvlc_rl_inter; |
3904 else rl = &rl_inter; | |
661 | 3905 |
718 | 3906 scan_table = s->intra_scantable.permutated; |
661 | 3907 |
591 | 3908 if(s->mpeg_quant){ |
3909 qmul=1; | |
3910 qadd=0; | |
1132 | 3911 if(rvlc){ |
3912 rl_vlc = rvlc_rl_inter.rl_vlc[0]; | |
3913 }else{ | |
3914 rl_vlc = rl_inter.rl_vlc[0]; | |
3915 } | |
591 | 3916 }else{ |
3917 qmul = s->qscale << 1; | |
3918 qadd = (s->qscale - 1) | 1; | |
1132 | 3919 if(rvlc){ |
3920 rl_vlc = rvlc_rl_inter.rl_vlc[s->qscale]; | |
3921 }else{ | |
3922 rl_vlc = rl_inter.rl_vlc[s->qscale]; | |
3923 } | |
591 | 3924 } |
0 | 3925 } |
549 | 3926 { |
3927 OPEN_READER(re, &s->gb); | |
0 | 3928 for(;;) { |
549 | 3929 UPDATE_CACHE(re, &s->gb); |
3930 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2); | |
3931 if (level==0) { | |
1132 | 3932 /* escape */ |
3933 if(rvlc){ | |
3934 if(SHOW_UBITS(re, &s->gb, 1)==0){ | |
3935 fprintf(stderr, "1. marker bit missing in rvlc esc\n"); | |
3936 return -1; | |
3937 }; SKIP_CACHE(re, &s->gb, 1); | |
3938 | |
3939 last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1); | |
3940 run= SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6); | |
3941 SKIP_COUNTER(re, &s->gb, 1+1+6); | |
3942 UPDATE_CACHE(re, &s->gb); | |
3943 | |
3944 if(SHOW_UBITS(re, &s->gb, 1)==0){ | |
3945 fprintf(stderr, "2. marker bit missing in rvlc esc\n"); | |
3946 return -1; | |
3947 }; SKIP_CACHE(re, &s->gb, 1); | |
3948 | |
3949 level= SHOW_UBITS(re, &s->gb, 11); SKIP_CACHE(re, &s->gb, 11); | |
3950 | |
3951 if(SHOW_UBITS(re, &s->gb, 5)!=0x10){ | |
3952 fprintf(stderr, "reverse esc missing\n"); | |
3953 return -1; | |
3954 }; SKIP_CACHE(re, &s->gb, 5); | |
3955 | |
3956 level= level * qmul + qadd; | |
3957 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); LAST_SKIP_CACHE(re, &s->gb, 1); | |
3958 SKIP_COUNTER(re, &s->gb, 1+11+5+1); | |
3959 | |
3960 i+= run + 1; | |
1271
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
3961 if(last) i+=192; |
1132 | 3962 }else{ |
549 | 3963 int cache; |
3964 cache= GET_CACHE(re, &s->gb); | |
1271
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
3965 |
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
3966 if(IS_3IV1) |
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
3967 cache ^= 0xC0000000; |
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
3968 |
549 | 3969 if (cache&0x80000000) { |
3970 if (cache&0x40000000) { | |
0 | 3971 /* third escape */ |
549 | 3972 SKIP_CACHE(re, &s->gb, 2); |
3973 last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1); | |
3974 run= SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6); | |
3975 SKIP_COUNTER(re, &s->gb, 2+1+6); | |
3976 UPDATE_CACHE(re, &s->gb); | |
3977 | |
1271
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
3978 if(IS_3IV1){ |
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
3979 level= SHOW_SBITS(re, &s->gb, 12); LAST_SKIP_BITS(re, &s->gb, 12); |
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
3980 }else{ |
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
3981 if(SHOW_UBITS(re, &s->gb, 1)==0){ |
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
3982 fprintf(stderr, "1. marker bit missing in 3. esc\n"); |
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
3983 return -1; |
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
3984 }; SKIP_CACHE(re, &s->gb, 1); |
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
3985 |
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
3986 level= SHOW_SBITS(re, &s->gb, 12); SKIP_CACHE(re, &s->gb, 12); |
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
3987 |
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
3988 if(SHOW_UBITS(re, &s->gb, 1)==0){ |
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
3989 fprintf(stderr, "2. marker bit missing in 3. esc\n"); |
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
3990 return -1; |
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
3991 }; LAST_SKIP_CACHE(re, &s->gb, 1); |
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
3992 |
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
3993 SKIP_COUNTER(re, &s->gb, 1+12+1); |
42ea05e4a391
improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents:
1261
diff
changeset
|
3994 } |
549 | 3995 |
597 | 3996 if(level*s->qscale>1024 || level*s->qscale<-1024){ |
3997 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
|
3998 return -1; |
453 | 3999 } |
4000 #if 1 | |
4001 { | |
4002 const int abs_level= ABS(level); | |
921 | 4003 if(abs_level<=MAX_LEVEL && run<=MAX_RUN && !(s->workaround_bugs&FF_BUG_AC_VLC)){ |
498 | 4004 const int run1= run - rl->max_run[last][abs_level] - 1; |
453 | 4005 if(abs_level <= rl->max_level[last][run]){ |
4006 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
|
4007 return -1; |
453 | 4008 } |
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
|
4009 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
|
4010 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
|
4011 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
|
4012 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
|
4013 } |
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
|
4014 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
|
4015 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
|
4016 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
|
4017 } |
453 | 4018 } |
4019 } | |
4020 } | |
4021 #endif | |
549 | 4022 if (level>0) level= level * qmul + qadd; |
4023 else level= level * qmul - qadd; | |
4024 | |
4025 i+= run + 1; | |
4026 if(last) i+=192; | |
0 | 4027 } else { |
4028 /* second escape */ | |
549 | 4029 #if MIN_CACHE_BITS < 20 |
4030 LAST_SKIP_BITS(re, &s->gb, 2); | |
4031 UPDATE_CACHE(re, &s->gb); | |
4032 #else | |
4033 SKIP_BITS(re, &s->gb, 2); | |
4034 #endif | |
4035 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2); | |
4036 i+= run + rl->max_run[run>>7][level/qmul] +1; //FIXME opt indexing | |
4037 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); | |
4038 LAST_SKIP_BITS(re, &s->gb, 1); | |
0 | 4039 } |
4040 } else { | |
4041 /* first escape */ | |
549 | 4042 #if MIN_CACHE_BITS < 19 |
4043 LAST_SKIP_BITS(re, &s->gb, 1); | |
4044 UPDATE_CACHE(re, &s->gb); | |
4045 #else | |
4046 SKIP_BITS(re, &s->gb, 1); | |
4047 #endif | |
4048 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2); | |
4049 i+= run; | |
4050 level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//FIXME opt indexing | |
4051 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); | |
4052 LAST_SKIP_BITS(re, &s->gb, 1); | |
0 | 4053 } |
1132 | 4054 } |
0 | 4055 } else { |
549 | 4056 i+= run; |
4057 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); | |
4058 LAST_SKIP_BITS(re, &s->gb, 1); | |
0 | 4059 } |
549 | 4060 if (i > 62){ |
4061 i-= 192; | |
4062 if(i&(~63)){ | |
4063 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
|
4064 return -1; |
549 | 4065 } |
4066 | |
4067 block[scan_table[i]] = level; | |
0 | 4068 break; |
549 | 4069 } |
4070 | |
4071 block[scan_table[i]] = level; | |
0 | 4072 } |
549 | 4073 CLOSE_READER(re, &s->gb); |
4074 } | |
0 | 4075 not_coded: |
4076 if (s->mb_intra) { | |
4077 mpeg4_pred_ac(s, block, n, dc_pred_dir); | |
4078 if (s->ac_pred) { | |
549 | 4079 i = 63; /* XXX: not optimal */ |
0 | 4080 } |
4081 } | |
549 | 4082 s->block_last_index[n] = i; |
0 | 4083 return 0; |
4084 } | |
4085 | |
4086 /* most is hardcoded. should extend to handle all h263 streams */ | |
4087 int h263_decode_picture_header(MpegEncContext *s) | |
4088 { | |
1278
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4089 int format, width, height, i; |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4090 uint32_t startcode; |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4091 |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4092 align_get_bits(&s->gb); |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4093 |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4094 startcode= get_bits(&s->gb, 22-8); |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4095 |
1393 | 4096 for(i= s->gb.size_in_bits - get_bits_count(&s->gb); i>24; i-=8) { |
1278
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4097 startcode = ((startcode << 8) | get_bits(&s->gb, 8)) & 0x003FFFFF; |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4098 |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4099 if(startcode == 0x20) |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4100 break; |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4101 } |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4102 |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4103 if (startcode != 0x20) { |
355 | 4104 fprintf(stderr, "Bad picture start code\n"); |
0 | 4105 return -1; |
355 | 4106 } |
4107 /* temporal reference */ | |
231 | 4108 s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */ |
355 | 4109 |
4110 /* PTYPE starts here */ | |
4111 if (get_bits1(&s->gb) != 1) { | |
4112 /* marker */ | |
4113 fprintf(stderr, "Bad marker\n"); | |
4114 return -1; | |
4115 } | |
4116 if (get_bits1(&s->gb) != 0) { | |
4117 fprintf(stderr, "Bad H263 id\n"); | |
0 | 4118 return -1; /* h263 id */ |
355 | 4119 } |
21 | 4120 skip_bits1(&s->gb); /* split screen off */ |
4121 skip_bits1(&s->gb); /* camera off */ | |
4122 skip_bits1(&s->gb); /* freeze picture release off */ | |
0 | 4123 |
155
3c3449bce692
- Bug fix on MV prediction for MPEG4 caused by new H.263 GOB code.
pulento
parents:
154
diff
changeset
|
4124 /* Reset GOB number */ |
154
f914f710b8d0
- Fixed a bug on H.263 MV prediction for MB on GOBs limits.
pulento
parents:
144
diff
changeset
|
4125 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
|
4126 |
0 | 4127 format = get_bits(&s->gb, 3); |
355 | 4128 /* |
4129 0 forbidden | |
4130 1 sub-QCIF | |
4131 10 QCIF | |
4132 7 extended PTYPE (PLUSPTYPE) | |
4133 */ | |
0 | 4134 |
161 | 4135 if (format != 7 && format != 6) { |
0 | 4136 s->h263_plus = 0; |
4137 /* H.263v1 */ | |
4138 width = h263_format[format][0]; | |
4139 height = h263_format[format][1]; | |
4140 if (!width) | |
4141 return -1; | |
161 | 4142 |
21 | 4143 s->pict_type = I_TYPE + get_bits1(&s->gb); |
0 | 4144 |
21 | 4145 s->unrestricted_mv = get_bits1(&s->gb); |
0 | 4146 s->h263_long_vectors = s->unrestricted_mv; |
4147 | |
355 | 4148 if (get_bits1(&s->gb) != 0) { |
4149 fprintf(stderr, "H263 SAC not supported\n"); | |
0 | 4150 return -1; /* SAC: off */ |
355 | 4151 } |
161 | 4152 if (get_bits1(&s->gb) != 0) { |
4153 s->mv_type = MV_TYPE_8X8; /* Advanced prediction mode */ | |
4154 } | |
4155 | |
355 | 4156 if (get_bits1(&s->gb) != 0) { |
4157 fprintf(stderr, "H263 PB frame not supported\n"); | |
0 | 4158 return -1; /* not PB frame */ |
355 | 4159 } |
0 | 4160 s->qscale = get_bits(&s->gb, 5); |
21 | 4161 skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */ |
1393 | 4162 |
4163 s->width = width; | |
4164 s->height = height; | |
0 | 4165 } else { |
161 | 4166 int ufep; |
4167 | |
0 | 4168 /* H.263v2 */ |
161 | 4169 s->h263_plus = 1; |
4170 ufep = get_bits(&s->gb, 3); /* Update Full Extended PTYPE */ | |
355 | 4171 |
4172 /* ufep other than 0 and 1 are reserved */ | |
161 | 4173 if (ufep == 1) { |
4174 /* OPPTYPE */ | |
4175 format = get_bits(&s->gb, 3); | |
355 | 4176 dprintf("ufep=1, format: %d\n", format); |
161 | 4177 skip_bits(&s->gb,1); /* Custom PCF */ |
1089 | 4178 s->umvplus = get_bits(&s->gb, 1); /* Unrestricted Motion Vector */ |
161 | 4179 skip_bits1(&s->gb); /* Syntax-based Arithmetic Coding (SAC) */ |
4180 if (get_bits1(&s->gb) != 0) { | |
4181 s->mv_type = MV_TYPE_8X8; /* Advanced prediction mode */ | |
4182 } | |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
4183 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
|
4184 s->h263_aic = 1; |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
4185 } |
355 | 4186 |
1278
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4187 if (get_bits1(&s->gb) != 0) { |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4188 fprintf(stderr, "Deblocking Filter not supported\n"); |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4189 } |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4190 if (get_bits1(&s->gb) != 0) { |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4191 fprintf(stderr, "Slice Structured not supported\n"); |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4192 } |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4193 if (get_bits1(&s->gb) != 0) { |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4194 fprintf(stderr, "Reference Picture Selection not supported\n"); |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4195 } |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4196 if (get_bits1(&s->gb) != 0) { |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4197 fprintf(stderr, "Independent Segment Decoding not supported\n"); |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4198 } |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4199 if (get_bits1(&s->gb) != 0) { |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4200 fprintf(stderr, "Alternative Inter VLC not supported\n"); |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4201 } |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4202 if (get_bits1(&s->gb) != 0) { |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4203 fprintf(stderr, "Modified Quantization not supported\n"); |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4204 } |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4205 |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4206 skip_bits(&s->gb, 1); /* Prevent start code emulation */ |
355 | 4207 |
161 | 4208 skip_bits(&s->gb, 3); /* Reserved */ |
355 | 4209 } else if (ufep != 0) { |
4210 fprintf(stderr, "Bad UFEP type (%d)\n", ufep); | |
0 | 4211 return -1; |
355 | 4212 } |
161 | 4213 |
78 | 4214 /* MPPTYPE */ |
355 | 4215 s->pict_type = get_bits(&s->gb, 3) + I_TYPE; |
4216 dprintf("pict_type: %d\n", s->pict_type); | |
0 | 4217 if (s->pict_type != I_TYPE && |
4218 s->pict_type != P_TYPE) | |
4219 return -1; | |
250
3449316664b5
- Bug fix on RTYPE (rounding type) not being honoured by H.263+ decoder.
pulento
parents:
249
diff
changeset
|
4220 skip_bits(&s->gb, 2); |
3449316664b5
- Bug fix on RTYPE (rounding type) not being honoured by H.263+ decoder.
pulento
parents:
249
diff
changeset
|
4221 s->no_rounding = get_bits1(&s->gb); |
355 | 4222 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
|
4223 skip_bits(&s->gb, 4); |
78 | 4224 |
4225 /* Get the picture dimensions */ | |
161 | 4226 if (ufep) { |
4227 if (format == 6) { | |
4228 /* Custom Picture Format (CPFMT) */ | |
355 | 4229 s->aspect_ratio_info = get_bits(&s->gb, 4); |
4230 dprintf("aspect: %d\n", s->aspect_ratio_info); | |
4231 /* aspect ratios: | |
4232 0 - forbidden | |
4233 1 - 1:1 | |
4234 2 - 12:11 (CIF 4:3) | |
4235 3 - 10:11 (525-type 4:3) | |
4236 4 - 16:11 (CIF 16:9) | |
4237 5 - 40:33 (525-type 16:9) | |
4238 6-14 - reserved | |
4239 */ | |
161 | 4240 width = (get_bits(&s->gb, 9) + 1) * 4; |
4241 skip_bits1(&s->gb); | |
4242 height = get_bits(&s->gb, 9) * 4; | |
355 | 4243 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
|
4244 if (s->aspect_ratio_info == FF_ASPECT_EXTENDED) { |
355 | 4245 /* aspected dimensions */ |
669
b4bddbde44f3
aspect (ext. par too) support for h263 and mpeg4 (inc. build becouse of new vars)
al3x
parents:
667
diff
changeset
|
4246 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
|
4247 s->aspected_height = get_bits(&s->gb, 8); |
887 | 4248 }else{ |
4249 s->aspected_width = pixel_aspect[s->aspect_ratio_info][0]; | |
4250 s->aspected_height= pixel_aspect[s->aspect_ratio_info][1]; | |
355 | 4251 } |
4252 } else { | |
161 | 4253 width = h263_format[format][0]; |
4254 height = h263_format[format][1]; | |
4255 } | |
4256 if ((width == 0) || (height == 0)) | |
4257 return -1; | |
4258 s->width = width; | |
4259 s->height = height; | |
1089 | 4260 if (s->umvplus) { |
4261 if(get_bits1(&s->gb)==0) /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */ | |
4262 skip_bits1(&s->gb); | |
161 | 4263 } |
78 | 4264 } |
4265 | |
0 | 4266 s->qscale = get_bits(&s->gb, 5); |
4267 } | |
4268 /* PEI */ | |
21 | 4269 while (get_bits1(&s->gb) != 0) { |
4270 skip_bits(&s->gb, 8); | |
0 | 4271 } |
4272 s->f_code = 1; | |
498 | 4273 |
4274 if(s->h263_aic){ | |
4275 s->y_dc_scale_table= | |
4276 s->c_dc_scale_table= h263_aic_dc_scale_table; | |
4277 }else{ | |
4278 s->y_dc_scale_table= | |
4279 s->c_dc_scale_table= ff_mpeg1_dc_scale_table; | |
4280 } | |
4281 | |
1278
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4282 if(s->avctx->debug&FF_DEBUG_PICT_INFO){ |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4283 printf("qp:%d %c size:%d rnd:%d %s %s %s %s\n", |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4284 s->qscale, av_get_pict_type_char(s->pict_type), |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4285 s->gb.size_in_bits, 1-s->no_rounding, |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4286 s->mv_type == MV_TYPE_8X8 ? "ADV" : "", |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4287 s->umvplus ? "UMV" : "", |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4288 s->h263_long_vectors ? "LONG" : "", |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4289 s->h263_plus ? "+" : "" |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4290 ); |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4291 } |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4292 |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4293 |
0 | 4294 return 0; |
4295 } | |
4296 | |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4297 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
|
4298 { |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4299 int i; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4300 int a= 2<<s->sprite_warping_accuracy; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4301 int rho= 3-s->sprite_warping_accuracy; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4302 int r=16/a; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4303 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
|
4304 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
|
4305 int sprite_ref[4][2]; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4306 int virtual_ref[2][2]; |
753 | 4307 int w2, h2, w3, h3; |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4308 int alpha=0, beta=0; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4309 int w= s->width; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4310 int h= s->height; |
753 | 4311 int min_ab; |
4312 | |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4313 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
|
4314 int length; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4315 int x=0, y=0; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4316 |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4317 length= get_vlc(&s->gb, &sprite_trajectory); |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4318 if(length){ |
1254
604661d34c68
bitstream reader optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1237
diff
changeset
|
4319 x= get_xbits(&s->gb, length); |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4320 } |
255 | 4321 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
|
4322 |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4323 length= get_vlc(&s->gb, &sprite_trajectory); |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4324 if(length){ |
1254
604661d34c68
bitstream reader optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1237
diff
changeset
|
4325 y=get_xbits(&s->gb, length); |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4326 } |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4327 skip_bits1(&s->gb); /* marker bit */ |
255 | 4328 //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
|
4329 d[i][0]= x; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4330 d[i][1]= y; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4331 } |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4332 |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4333 while((1<<alpha)<w) alpha++; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4334 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
|
4335 w2= 1<<alpha; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4336 h2= 1<<beta; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4337 |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4338 // Note, the 4th point isnt used for GMC |
262 | 4339 if(s->divx_version==500 && s->divx_build==413){ |
4340 sprite_ref[0][0]= a*vop_ref[0][0] + d[0][0]; | |
4341 sprite_ref[0][1]= a*vop_ref[0][1] + d[0][1]; | |
4342 sprite_ref[1][0]= a*vop_ref[1][0] + d[0][0] + d[1][0]; | |
4343 sprite_ref[1][1]= a*vop_ref[1][1] + d[0][1] + d[1][1]; | |
4344 sprite_ref[2][0]= a*vop_ref[2][0] + d[0][0] + d[2][0]; | |
4345 sprite_ref[2][1]= a*vop_ref[2][1] + d[0][1] + d[2][1]; | |
4346 } else { | |
4347 sprite_ref[0][0]= (a>>1)*(2*vop_ref[0][0] + d[0][0]); | |
4348 sprite_ref[0][1]= (a>>1)*(2*vop_ref[0][1] + d[0][1]); | |
4349 sprite_ref[1][0]= (a>>1)*(2*vop_ref[1][0] + d[0][0] + d[1][0]); | |
4350 sprite_ref[1][1]= (a>>1)*(2*vop_ref[1][1] + d[0][1] + d[1][1]); | |
4351 sprite_ref[2][0]= (a>>1)*(2*vop_ref[2][0] + d[0][0] + d[2][0]); | |
4352 sprite_ref[2][1]= (a>>1)*(2*vop_ref[2][1] + d[0][1] + d[2][1]); | |
4353 } | |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4354 /* 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
|
4355 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
|
4356 |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4357 // 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
|
4358 // 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
|
4359 // 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
|
4360 // 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
|
4361 virtual_ref[0][0]= 16*(vop_ref[0][0] + w2) |
359 | 4362 + 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
|
4363 virtual_ref[0][1]= 16*vop_ref[0][1] |
359 | 4364 + 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
|
4365 virtual_ref[1][0]= 16*vop_ref[0][0] |
359 | 4366 + 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
|
4367 virtual_ref[1][1]= 16*(vop_ref[0][1] + h2) |
359 | 4368 + 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 | 4369 |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4370 switch(s->num_sprite_warping_points) |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4371 { |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4372 case 0: |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4373 s->sprite_offset[0][0]= 0; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4374 s->sprite_offset[0][1]= 0; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4375 s->sprite_offset[1][0]= 0; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4376 s->sprite_offset[1][1]= 0; |
753 | 4377 s->sprite_delta[0][0]= a; |
4378 s->sprite_delta[0][1]= 0; | |
4379 s->sprite_delta[1][0]= 0; | |
4380 s->sprite_delta[1][1]= a; | |
4381 s->sprite_shift[0]= 0; | |
4382 s->sprite_shift[1]= 0; | |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4383 break; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4384 case 1: //GMC only |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4385 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
|
4386 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
|
4387 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
|
4388 s->sprite_offset[1][1]= ((sprite_ref[0][1]>>1)|(sprite_ref[0][1]&1)) - a*(vop_ref[0][1]/2); |
753 | 4389 s->sprite_delta[0][0]= a; |
4390 s->sprite_delta[0][1]= 0; | |
4391 s->sprite_delta[1][0]= 0; | |
4392 s->sprite_delta[1][1]= a; | |
4393 s->sprite_shift[0]= 0; | |
4394 s->sprite_shift[1]= 0; | |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4395 break; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4396 case 2: |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4397 s->sprite_offset[0][0]= (sprite_ref[0][0]<<(alpha+rho)) |
753 | 4398 + (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][0]) |
4399 + ( r*sprite_ref[0][1] - virtual_ref[0][1])*(-vop_ref[0][1]) | |
4400 + (1<<(alpha+rho-1)); | |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4401 s->sprite_offset[0][1]= (sprite_ref[0][1]<<(alpha+rho)) |
753 | 4402 + (-r*sprite_ref[0][1] + virtual_ref[0][1])*(-vop_ref[0][0]) |
4403 + (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][1]) | |
4404 + (1<<(alpha+rho-1)); | |
4405 s->sprite_offset[1][0]= ( (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][0] + 1) | |
4406 +( r*sprite_ref[0][1] - virtual_ref[0][1])*(-2*vop_ref[0][1] + 1) | |
4407 +2*w2*r*sprite_ref[0][0] | |
4408 - 16*w2 | |
4409 + (1<<(alpha+rho+1))); | |
4410 s->sprite_offset[1][1]= ( (-r*sprite_ref[0][1] + virtual_ref[0][1])*(-2*vop_ref[0][0] + 1) | |
4411 +(-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][1] + 1) | |
4412 +2*w2*r*sprite_ref[0][1] | |
4413 - 16*w2 | |
4414 + (1<<(alpha+rho+1))); | |
4415 s->sprite_delta[0][0]= (-r*sprite_ref[0][0] + virtual_ref[0][0]); | |
4416 s->sprite_delta[0][1]= (+r*sprite_ref[0][1] - virtual_ref[0][1]); | |
4417 s->sprite_delta[1][0]= (-r*sprite_ref[0][1] + virtual_ref[0][1]); | |
4418 s->sprite_delta[1][1]= (-r*sprite_ref[0][0] + virtual_ref[0][0]); | |
4419 | |
4420 s->sprite_shift[0]= alpha+rho; | |
4421 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
|
4422 break; |
753 | 4423 case 3: |
847 | 4424 min_ab= FFMIN(alpha, beta); |
753 | 4425 w3= w2>>min_ab; |
4426 h3= h2>>min_ab; | |
4427 s->sprite_offset[0][0]= (sprite_ref[0][0]<<(alpha+beta+rho-min_ab)) | |
4428 + (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3*(-vop_ref[0][0]) | |
4429 + (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3*(-vop_ref[0][1]) | |
4430 + (1<<(alpha+beta+rho-min_ab-1)); | |
4431 s->sprite_offset[0][1]= (sprite_ref[0][1]<<(alpha+beta+rho-min_ab)) | |
4432 + (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3*(-vop_ref[0][0]) | |
4433 + (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3*(-vop_ref[0][1]) | |
4434 + (1<<(alpha+beta+rho-min_ab-1)); | |
4435 s->sprite_offset[1][0]= (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3*(-2*vop_ref[0][0] + 1) | |
4436 + (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3*(-2*vop_ref[0][1] + 1) | |
4437 + 2*w2*h3*r*sprite_ref[0][0] | |
4438 - 16*w2*h3 | |
4439 + (1<<(alpha+beta+rho-min_ab+1)); | |
4440 s->sprite_offset[1][1]= (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3*(-2*vop_ref[0][0] + 1) | |
4441 + (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3*(-2*vop_ref[0][1] + 1) | |
4442 + 2*w2*h3*r*sprite_ref[0][1] | |
4443 - 16*w2*h3 | |
4444 + (1<<(alpha+beta+rho-min_ab+1)); | |
4445 s->sprite_delta[0][0]= (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3; | |
4446 s->sprite_delta[0][1]= (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3; | |
4447 s->sprite_delta[1][0]= (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3; | |
4448 s->sprite_delta[1][1]= (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3; | |
4449 | |
4450 s->sprite_shift[0]= alpha + beta + rho - min_ab; | |
4451 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
|
4452 break; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4453 } |
255 | 4454 /* try to simplify the situation */ |
753 | 4455 if( s->sprite_delta[0][0] == a<<s->sprite_shift[0] |
4456 && s->sprite_delta[0][1] == 0 | |
4457 && s->sprite_delta[1][0] == 0 | |
4458 && s->sprite_delta[1][1] == a<<s->sprite_shift[0]) | |
255 | 4459 { |
753 | 4460 s->sprite_offset[0][0]>>=s->sprite_shift[0]; |
4461 s->sprite_offset[0][1]>>=s->sprite_shift[0]; | |
4462 s->sprite_offset[1][0]>>=s->sprite_shift[1]; | |
4463 s->sprite_offset[1][1]>>=s->sprite_shift[1]; | |
4464 s->sprite_delta[0][0]= a; | |
4465 s->sprite_delta[0][1]= 0; | |
4466 s->sprite_delta[1][0]= 0; | |
4467 s->sprite_delta[1][1]= a; | |
4468 s->sprite_shift[0]= 0; | |
4469 s->sprite_shift[1]= 0; | |
255 | 4470 s->real_sprite_warping_points=1; |
4471 } | |
753 | 4472 else{ |
4473 int shift_y= 16 - s->sprite_shift[0]; | |
4474 int shift_c= 16 - s->sprite_shift[1]; | |
4475 //printf("shifts %d %d\n", shift_y, shift_c); | |
4476 for(i=0; i<2; i++){ | |
4477 s->sprite_offset[0][i]<<= shift_y; | |
4478 s->sprite_offset[1][i]<<= shift_c; | |
4479 s->sprite_delta[0][i]<<= shift_y; | |
4480 s->sprite_delta[1][i]<<= shift_y; | |
4481 s->sprite_shift[i]= 16; | |
4482 } | |
255 | 4483 s->real_sprite_warping_points= s->num_sprite_warping_points; |
753 | 4484 } |
4485 #if 0 | |
4486 printf("vop:%d:%d %d:%d %d:%d, sprite:%d:%d %d:%d %d:%d, virtual: %d:%d %d:%d\n", | |
4487 vop_ref[0][0], vop_ref[0][1], | |
4488 vop_ref[1][0], vop_ref[1][1], | |
4489 vop_ref[2][0], vop_ref[2][1], | |
4490 sprite_ref[0][0], sprite_ref[0][1], | |
4491 sprite_ref[1][0], sprite_ref[1][1], | |
4492 sprite_ref[2][0], sprite_ref[2][1], | |
4493 virtual_ref[0][0], virtual_ref[0][1], | |
4494 virtual_ref[1][0], virtual_ref[1][1] | |
4495 ); | |
4496 | |
4497 printf("offset: %d:%d , delta: %d %d %d %d, shift %d\n", | |
4498 s->sprite_offset[0][0], s->sprite_offset[0][1], | |
4499 s->sprite_delta[0][0], s->sprite_delta[0][1], | |
4500 s->sprite_delta[1][0], s->sprite_delta[1][1], | |
4501 s->sprite_shift[0] | |
4502 ); | |
4503 #endif | |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4504 } |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4505 |
942 | 4506 static int mpeg4_decode_gop_header(MpegEncContext * s, GetBitContext *gb){ |
4507 int hours, minutes, seconds; | |
4508 | |
4509 hours= get_bits(gb, 5); | |
4510 minutes= get_bits(gb, 6); | |
4511 skip_bits1(gb); | |
4512 seconds= get_bits(gb, 6); | |
4513 | |
4514 s->time_base= seconds + 60*(minutes + 60*hours); | |
4515 | |
4516 skip_bits1(gb); | |
4517 skip_bits1(gb); | |
4518 | |
4519 return 0; | |
4520 } | |
4521 | |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4522 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
|
4523 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
|
4524 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4525 /* vol header */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4526 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
|
4527 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
|
4528 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
|
4529 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
|
4530 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
|
4531 } else { |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4532 vo_ver_id = 1; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4533 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4534 //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
|
4535 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
|
4536 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
|
4537 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
|
4538 s->aspected_height = get_bits(gb, 8); // par_height |
887 | 4539 }else{ |
4540 s->aspected_width = pixel_aspect[s->aspect_ratio_info][0]; | |
4541 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
|
4542 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4543 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4544 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
|
4545 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
|
4546 if(chroma_format!=1){ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4547 printf("illegal chroma format\n"); |
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 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
|
4550 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
|
4551 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
|
4552 skip_bits1(gb); /* marker */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4553 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
|
4554 skip_bits1(gb); /* marker */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4555 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
|
4556 skip_bits1(gb); /* marker */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4557 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
|
4558 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
|
4559 skip_bits1(gb); /* marker */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4560 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
|
4561 skip_bits1(gb); /* marker */ |
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 }else{ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4564 // 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
|
4565 if(s->picture_number==0) |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4566 s->low_delay=0; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4567 } |
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 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
|
4570 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
|
4571 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
|
4572 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
|
4573 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
|
4574 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4575 |
1411 | 4576 check_marker(gb, "before time_increment_resolution"); |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4577 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4578 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
|
4579 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4580 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
|
4581 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
|
4582 s->time_increment_bits = 1; |
1411 | 4583 |
4584 check_marker(gb, "before fixed_vop_rate"); | |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4585 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4586 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
|
4587 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
|
4588 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4589 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4590 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
|
4591 if (s->shape == RECT_SHAPE) { |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4592 skip_bits1(gb); /* marker */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4593 width = get_bits(gb, 13); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4594 skip_bits1(gb); /* marker */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4595 height = get_bits(gb, 13); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4596 skip_bits1(gb); /* marker */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4597 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
|
4598 s->width = width; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4599 s->height = height; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4600 // 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
|
4601 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4602 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4603 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4604 s->progressive_sequence= get_bits1(gb)^1; |
1237 | 4605 if(!get_bits1(gb) && (s->avctx->debug & FF_DEBUG_PICT_INFO)) |
4606 printf("OBMC not supported (very likely buggy encoder)\n"); /* OBMC Disable */ | |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4607 if (vo_ver_id == 1) { |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4608 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
|
4609 } else { |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4610 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
|
4611 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4612 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
|
4613 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
|
4614 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
|
4615 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
|
4616 skip_bits1(gb); /* marker */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4617 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
|
4618 skip_bits1(gb); /* marker */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4619 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
|
4620 skip_bits1(gb); /* marker */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4621 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
|
4622 skip_bits1(gb); /* marker */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4623 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4624 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
|
4625 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
|
4626 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
|
4627 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
|
4628 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
|
4629 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4630 // 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
|
4631 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4632 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
|
4633 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
|
4634 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
|
4635 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
|
4636 } else { |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4637 s->quant_precision = 5; |
0 | 4638 } |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4639 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4640 // 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
|
4641 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4642 if((s->mpeg_quant=get_bits1(gb))){ /* vol_quant_type */ |
1057 | 4643 int i, v; |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4644 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4645 /* load default matrixes */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4646 for(i=0; i<64; i++){ |
1092 | 4647 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
|
4648 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
|
4649 s->intra_matrix[j]= v; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4650 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
|
4651 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4652 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
|
4653 s->inter_matrix[j]= v; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4654 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
|
4655 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4656 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4657 /* load custom intra matrix */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4658 if(get_bits1(gb)){ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4659 int last=0; |
1057 | 4660 for(i=0; i<64; i++){ |
4661 int j; | |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4662 v= get_bits(gb, 8); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4663 if(v==0) break; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4664 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4665 last= v; |
1092 | 4666 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
|
4667 s->intra_matrix[j]= v; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4668 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
|
4669 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4670 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4671 /* replicate last value */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4672 for(; i<64; i++){ |
1092 | 4673 int j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ]; |
1411 | 4674 s->intra_matrix[j]= last; |
4675 s->chroma_intra_matrix[j]= last; | |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4676 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4677 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4678 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4679 /* load custom non intra matrix */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4680 if(get_bits1(gb)){ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4681 int last=0; |
1057 | 4682 for(i=0; i<64; i++){ |
4683 int j; | |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4684 v= get_bits(gb, 8); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4685 if(v==0) break; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4686 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4687 last= v; |
1092 | 4688 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
|
4689 s->inter_matrix[j]= v; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4690 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
|
4691 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4692 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4693 /* replicate last value */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4694 for(; i<64; i++){ |
1092 | 4695 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
|
4696 s->inter_matrix[j]= last; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4697 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
|
4698 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4699 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4700 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4701 // 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
|
4702 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4703 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4704 if(vo_ver_id != 1) |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4705 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
|
4706 else s->quarter_sample=0; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4707 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4708 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
|
4709 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4710 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
|
4711 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4712 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
|
4713 if(s->data_partitioning){ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4714 s->rvlc= get_bits1(gb); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4715 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4716 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4717 if(vo_ver_id != 1) { |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4718 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
|
4719 if(s->new_pred){ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4720 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
|
4721 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
|
4722 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
|
4723 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4724 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
|
4725 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
|
4726 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4727 else{ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4728 s->new_pred=0; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4729 s->reduced_res_vop= 0; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4730 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4731 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4732 s->scalability= get_bits1(gb); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4733 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4734 if (s->scalability) { |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4735 GetBitContext bak= *gb; |
751 | 4736 int ref_layer_id; |
4737 int ref_layer_sampling_dir; | |
4738 int h_sampling_factor_n; | |
4739 int h_sampling_factor_m; | |
4740 int v_sampling_factor_n; | |
4741 int v_sampling_factor_m; | |
4742 | |
4743 s->hierachy_type= get_bits1(gb); | |
4744 ref_layer_id= get_bits(gb, 4); | |
4745 ref_layer_sampling_dir= get_bits1(gb); | |
4746 h_sampling_factor_n= get_bits(gb, 5); | |
4747 h_sampling_factor_m= get_bits(gb, 5); | |
4748 v_sampling_factor_n= get_bits(gb, 5); | |
4749 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
|
4750 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
|
4751 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4752 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
|
4753 || 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
|
4754 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4755 // 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
|
4756 s->scalability=0; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4757 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4758 *gb= bak; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4759 }else |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4760 printf("scalability not supported\n"); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4761 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4762 // bin shape stuff FIXME |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4763 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4764 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4765 return 0; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4766 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4767 |
1034 | 4768 /** |
4769 * decodes the user data stuff in the header. | |
4770 * allso inits divx/xvid/lavc_version/build | |
4771 */ | |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4772 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
|
4773 char buf[256]; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4774 int i; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4775 int e; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4776 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
|
4777 char last; |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4778 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4779 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
|
4780 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
|
4781 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
|
4782 if(buf[i]==0) break; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4783 skip_bits(gb, 8); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4784 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4785 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
|
4786 |
761 | 4787 /* 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
|
4788 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
|
4789 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
|
4790 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
|
4791 if(e>=2){ |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4792 s->divx_version= ver; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4793 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
|
4794 s->divx_packed= e==3 && last=='p'; |
0 | 4795 } |
761 | 4796 |
4797 /* ffmpeg detection */ | |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4798 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
|
4799 if(e!=4) |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4800 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
|
4801 if(e!=4){ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4802 if(strcmp(buf, "ffmpeg")==0){ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4803 s->ffmpeg_version= 0x000406; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4804 s->lavc_build= 4600; |
63 | 4805 } |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4806 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4807 if(e==4){ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4808 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
|
4809 s->lavc_build= build; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4810 } |
761 | 4811 |
4812 /* xvid detection */ | |
4813 e=sscanf(buf, "XviD%d", &build); | |
4814 if(e==1){ | |
4815 s->xvid_build= build; | |
4816 } | |
4817 | |
255 | 4818 //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
|
4819 return 0; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4820 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4821 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4822 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
|
4823 int time_incr, time_increment; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4824 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4825 s->pict_type = get_bits(gb, 2) + I_TYPE; /* pict type: I = 0 , P = 1 */ |
1346 | 4826 if(s->pict_type==B_TYPE && s->low_delay && s->vol_control_parameters==0 && !(s->flags & CODEC_FLAG_LOW_DELAY)){ |
365
fdeec2834c79
there are divx5? encoded files without a userdata section but with b-frames :(
michaelni
parents:
364
diff
changeset
|
4827 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
|
4828 s->low_delay=0; |
fdeec2834c79
there are divx5? encoded files without a userdata section but with b-frames :(
michaelni
parents:
364
diff
changeset
|
4829 } |
753 | 4830 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4831 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
|
4832 if(s->partitioned_frame) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4833 s->decode_mb= mpeg4_decode_partitioned_mb; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4834 else |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4835 s->decode_mb= ff_h263_decode_mb; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4836 |
662
5a158f0d1981
fixing 1/0 if the headers are incomplete (like what M$ encoder generates)
michaelni
parents:
661
diff
changeset
|
4837 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
|
4838 s->time_increment_resolution=1; |
5a158f0d1981
fixing 1/0 if the headers are incomplete (like what M$ encoder generates)
michaelni
parents:
661
diff
changeset
|
4839 // 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
|
4840 } |
262 | 4841 time_incr=0; |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4842 while (get_bits1(gb) != 0) |
0 | 4843 time_incr++; |
4844 | |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4845 check_marker(gb, "before time_increment"); |
1068 | 4846 |
1396 | 4847 if(s->time_increment_bits==0){ |
1068 | 4848 printf("hmm, seems the headers arnt complete, trying to guess time_increment_bits\n"); |
4849 | |
4850 for(s->time_increment_bits=1 ;s->time_increment_bits<16; s->time_increment_bits++){ | |
4851 if(show_bits(gb, s->time_increment_bits+1)&1) break; | |
4852 } | |
1396 | 4853 |
1068 | 4854 printf("my guess is %d bits ;)\n",s->time_increment_bits); |
4855 } | |
4856 | |
1411 | 4857 if(IS_3IV1) time_increment= get_bits1(gb); //FIXME investigate further |
4858 else time_increment= get_bits(gb, s->time_increment_bits); | |
4859 | |
4860 // printf("%d %X\n", s->time_increment_bits, time_increment); | |
697 | 4861 //printf(" type:%d modulo_time_base:%d increment:%d\n", s->pict_type, time_incr, time_increment); |
262 | 4862 if(s->pict_type!=B_TYPE){ |
324 | 4863 s->last_time_base= s->time_base; |
262 | 4864 s->time_base+= time_incr; |
324 | 4865 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
|
4866 if(s->workaround_bugs&FF_BUG_UMP4){ |
700
0fb4c66527e1
autodetect UMP4 (by adding a fourcc field to AVCodecContext)
michaelni
parents:
699
diff
changeset
|
4867 if(s->time < s->last_non_b_time){ |
0fb4c66527e1
autodetect UMP4 (by adding a fourcc field to AVCodecContext)
michaelni
parents:
699
diff
changeset
|
4868 // 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
|
4869 s->time_base++; |
0fb4c66527e1
autodetect UMP4 (by adding a fourcc field to AVCodecContext)
michaelni
parents:
699
diff
changeset
|
4870 s->time+= s->time_increment_resolution; |
0fb4c66527e1
autodetect UMP4 (by adding a fourcc field to AVCodecContext)
michaelni
parents:
699
diff
changeset
|
4871 } |
664 | 4872 } |
324 | 4873 s->pp_time= s->time - s->last_non_b_time; |
4874 s->last_non_b_time= s->time; | |
262 | 4875 }else{ |
324 | 4876 s->time= (s->last_time_base + time_incr)*s->time_increment_resolution + time_increment; |
664 | 4877 s->pb_time= s->pp_time - (s->last_non_b_time - s->time); |
4878 if(s->pp_time <=s->pb_time || s->pp_time <= s->pp_time - s->pb_time || s->pp_time<=0){ | |
335 | 4879 // printf("messed up order, seeking?, skiping current b frame\n"); |
4880 return FRAME_SKIPED; | |
4881 } | |
664 | 4882 |
4883 if(s->t_frame==0) s->t_frame= s->time - s->last_time_base; | |
4884 if(s->t_frame==0) s->t_frame=1; // 1/0 protection | |
4885 //printf("%Ld %Ld %d %d\n", s->last_non_b_time, s->time, s->pp_time, s->t_frame); fflush(stdout); | |
4886 s->pp_field_time= ( ROUNDED_DIV(s->last_non_b_time, s->t_frame) | |
4887 - ROUNDED_DIV(s->last_non_b_time - s->pp_time, s->t_frame))*2; | |
4888 s->pb_field_time= ( ROUNDED_DIV(s->time, s->t_frame) | |
4889 - ROUNDED_DIV(s->last_non_b_time - s->pp_time, s->t_frame))*2; | |
262 | 4890 } |
654 | 4891 |
903 | 4892 s->current_picture.pts= s->time*1000LL*1000LL / s->time_increment_resolution; |
942 | 4893 if(s->avctx->debug&FF_DEBUG_PTS) |
4894 printf("MPEG4 PTS: %f\n", s->current_picture.pts/(1000.0*1000.0)); | |
654 | 4895 |
1068 | 4896 check_marker(gb, "before vop_coded"); |
4897 | |
0 | 4898 /* vop coded */ |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4899 if (get_bits1(gb) != 1){ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4900 printf("vop not coded\n"); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4901 return FRAME_SKIPED; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4902 } |
664 | 4903 //printf("time %d %d %d || %Ld %Ld %Ld\n", s->time_increment_bits, s->time_increment_resolution, s->time_base, |
4904 //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
|
4905 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
|
4906 || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE))) { |
0 | 4907 /* 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
|
4908 s->no_rounding = get_bits1(gb); |
63 | 4909 } else { |
4910 s->no_rounding = 0; | |
0 | 4911 } |
253
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
4912 //FIXME reduced res stuff |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
4913 |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
4914 if (s->shape != RECT_SHAPE) { |
63 | 4915 if (s->vol_sprite_usage != 1 || s->pict_type != I_TYPE) { |
4916 int width, height, hor_spat_ref, ver_spat_ref; | |
4917 | |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4918 width = get_bits(gb, 13); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4919 skip_bits1(gb); /* marker */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4920 height = get_bits(gb, 13); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4921 skip_bits1(gb); /* marker */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4922 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
|
4923 skip_bits1(gb); /* marker */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4924 ver_spat_ref = get_bits(gb, 13); /* ver_spat_ref */ |
63 | 4925 } |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4926 skip_bits1(gb); /* change_CR_disable */ |
63 | 4927 |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4928 if (get_bits1(gb) != 0) { |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4929 skip_bits(gb, 8); /* constant_alpha_value */ |
63 | 4930 } |
4931 } | |
253
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
4932 //FIXME complexity estimation stuff |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
4933 |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
4934 if (s->shape != BIN_ONLY_SHAPE) { |
290 | 4935 int t; |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4936 t=get_bits(gb, 3); /* intra dc VLC threshold */ |
290 | 4937 //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
|
4938 if(!s->progressive_sequence){ |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4939 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
|
4940 s->alternate_scan= get_bits1(gb); |
661 | 4941 }else |
4942 s->alternate_scan= 0; | |
253
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
4943 } |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4944 |
718 | 4945 if(s->alternate_scan){ |
1273 | 4946 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_alternate_vertical_scan); |
4947 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_alternate_vertical_scan); | |
4948 ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_vertical_scan); | |
4949 ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan); | |
718 | 4950 } else{ |
1273 | 4951 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_zigzag_direct); |
4952 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_zigzag_direct); | |
4953 ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan); | |
4954 ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan); | |
718 | 4955 } |
4956 | |
253
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
4957 if(s->pict_type == S_TYPE && (s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE)){ |
821 | 4958 mpeg4_decode_sprite_trajectory(s); |
253
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
4959 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
|
4960 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
|
4961 } |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
4962 |
253
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
4963 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
|
4964 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
|
4965 if(s->qscale==0){ |
28c5c62b1c4c
support decoding (with mplayer) of 3 .mp4 files from mphq
michaelni
parents:
263
diff
changeset
|
4966 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
|
4967 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
|
4968 } |
63 | 4969 |
4970 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
|
4971 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
|
4972 if(s->f_code==0){ |
28c5c62b1c4c
support decoding (with mplayer) of 3 .mp4 files from mphq
michaelni
parents:
263
diff
changeset
|
4973 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
|
4974 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
|
4975 } |
582
5132a4ee50cd
different edge positions fixed with edge emu / dr1
michaelni
parents:
575
diff
changeset
|
4976 }else |
5132a4ee50cd
different edge positions fixed with edge emu / dr1
michaelni
parents:
575
diff
changeset
|
4977 s->f_code=1; |
5132a4ee50cd
different edge positions fixed with edge emu / dr1
michaelni
parents:
575
diff
changeset
|
4978 |
253
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
4979 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
|
4980 s->b_code = get_bits(gb, 3); |
582
5132a4ee50cd
different edge positions fixed with edge emu / dr1
michaelni
parents:
575
diff
changeset
|
4981 }else |
5132a4ee50cd
different edge positions fixed with edge emu / dr1
michaelni
parents:
575
diff
changeset
|
4982 s->b_code=1; |
906 | 4983 |
4984 if(s->avctx->debug&FF_DEBUG_PICT_INFO){ | |
1457 | 4985 printf("qp:%d fc:%d,%d %s size:%d pro:%d alt:%d top:%d %spel part:%d resync:%d w:%d a:%d rnd:%d vot:%d%s\n", |
906 | 4986 s->qscale, s->f_code, s->b_code, |
4987 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
|
4988 gb->size_in_bits,s->progressive_sequence, s->alternate_scan, s->top_field_first, |
930 | 4989 s->quarter_sample ? "q" : "h", s->data_partitioning, s->resync_marker, s->num_sprite_warping_points, |
1457 | 4990 s->sprite_warping_accuracy, 1-s->no_rounding, s->vo_type, s->vol_control_parameters ? " VOLC" : " "); |
906 | 4991 } |
4992 | |
253
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
4993 if(!s->scalability){ |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
4994 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
|
4995 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
|
4996 } |
575 | 4997 }else{ |
4998 if(s->enhancement_type){ | |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
4999 int load_backward_shape= get_bits1(gb); |
575 | 5000 if(load_backward_shape){ |
5001 printf("load backward shape isnt supported\n"); | |
5002 } | |
5003 } | |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5004 skip_bits(gb, 2); //ref_select_code |
63 | 5005 } |
5006 } | |
346
c2f789fe4945
detecting xvid/divx4/opendivx and set low_delay flag
michaelni
parents:
344
diff
changeset
|
5007 /* 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
|
5008 // 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
|
5009 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
|
5010 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
|
5011 s->low_delay=1; |
c2f789fe4945
detecting xvid/divx4/opendivx and set low_delay flag
michaelni
parents:
344
diff
changeset
|
5012 } |
c2f789fe4945
detecting xvid/divx4/opendivx and set low_delay flag
michaelni
parents:
344
diff
changeset
|
5013 |
255 | 5014 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
|
5015 |
498 | 5016 s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table; //FIXME add short header support |
5017 s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table; | |
5018 | |
1366
80067f8d6770
fix edge repeating bug for %16!=0 files, this fixes Quicktime mpeg4 (they arent buggy)
michaelni
parents:
1364
diff
changeset
|
5019 if(s->workaround_bugs&FF_BUG_EDGE){ |
582
5132a4ee50cd
different edge positions fixed with edge emu / dr1
michaelni
parents:
575
diff
changeset
|
5020 s->h_edge_pos= s->width; |
5132a4ee50cd
different edge positions fixed with edge emu / dr1
michaelni
parents:
575
diff
changeset
|
5021 s->v_edge_pos= s->height; |
5132a4ee50cd
different edge positions fixed with edge emu / dr1
michaelni
parents:
575
diff
changeset
|
5022 } |
63 | 5023 return 0; |
0 | 5024 } |
5025 | |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5026 /** |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5027 * decode mpeg4 headers |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5028 * @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
|
5029 * 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
|
5030 * 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
|
5031 */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5032 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
|
5033 { |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5034 int startcode, v; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5035 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5036 /* search next start code */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5037 align_get_bits(gb); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5038 startcode = 0xff; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5039 for(;;) { |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5040 v = get_bits(gb, 8); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5041 startcode = ((startcode << 8) | v) & 0xffffffff; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5042 |
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
|
5043 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
|
5044 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
|
5045 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
|
5046 return FRAME_SKIPED; //divx bug |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5047 }else |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5048 return -1; //end of stream |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5049 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5050 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5051 if((startcode&0xFFFFFF00) != 0x100) |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5052 continue; //no startcode |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5053 |
942 | 5054 if(s->avctx->debug&FF_DEBUG_STARTCODE){ |
5055 printf("startcode: %3X ", startcode); | |
5056 if (startcode<=0x11F) printf("Video Object Start"); | |
5057 else if(startcode<=0x12F) printf("Video Object Layer Start"); | |
5058 else if(startcode<=0x13F) printf("Reserved"); | |
5059 else if(startcode<=0x15F) printf("FGS bp start"); | |
5060 else if(startcode<=0x1AF) printf("Reserved"); | |
5061 else if(startcode==0x1B0) printf("Visual Object Seq Start"); | |
5062 else if(startcode==0x1B1) printf("Visual Object Seq End"); | |
5063 else if(startcode==0x1B2) printf("User Data"); | |
5064 else if(startcode==0x1B3) printf("Group of VOP start"); | |
5065 else if(startcode==0x1B4) printf("Video Session Error"); | |
5066 else if(startcode==0x1B5) printf("Visual Object Start"); | |
5067 else if(startcode==0x1B6) printf("Video Object Plane start"); | |
5068 else if(startcode==0x1B7) printf("slice start"); | |
5069 else if(startcode==0x1B8) printf("extension start"); | |
5070 else if(startcode==0x1B9) printf("fgs start"); | |
5071 else if(startcode==0x1BA) printf("FBA Object start"); | |
5072 else if(startcode==0x1BB) printf("FBA Object Plane start"); | |
5073 else if(startcode==0x1BC) printf("Mesh Object start"); | |
5074 else if(startcode==0x1BD) printf("Mesh Object Plane start"); | |
5075 else if(startcode==0x1BE) printf("Still Textutre Object start"); | |
5076 else if(startcode==0x1BF) printf("Textutre Spatial Layer start"); | |
5077 else if(startcode==0x1C0) printf("Textutre SNR Layer start"); | |
5078 else if(startcode==0x1C1) printf("Textutre Tile start"); | |
5079 else if(startcode==0x1C2) printf("Textutre Shape Layer start"); | |
5080 else if(startcode==0x1C3) printf("stuffing start"); | |
5081 else if(startcode<=0x1C5) printf("reserved"); | |
5082 else if(startcode<=0x1FF) printf("System start"); | |
5083 printf(" at %d\n", get_bits_count(gb)); | |
5084 } | |
5085 | |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5086 switch(startcode){ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5087 case 0x120: |
1396 | 5088 if(decode_vol_header(s, gb) < 0) |
5089 return -1; | |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5090 break; |
942 | 5091 case USER_DATA_STARTCODE: |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5092 decode_user_data(s, gb); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5093 break; |
942 | 5094 case GOP_STARTCODE: |
5095 mpeg4_decode_gop_header(s, gb); | |
5096 break; | |
5097 case VOP_STARTCODE: | |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5098 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
|
5099 default: |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5100 break; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5101 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5102 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5103 align_get_bits(gb); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5104 startcode = 0xff; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5105 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5106 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5107 |
0 | 5108 /* don't understand why they choose a different header ! */ |
5109 int intel_h263_decode_picture_header(MpegEncContext *s) | |
5110 { | |
5111 int format; | |
5112 | |
5113 /* picture header */ | |
1257 | 5114 if (get_bits_long(&s->gb, 22) != 0x20) { |
355 | 5115 fprintf(stderr, "Bad picture start code\n"); |
0 | 5116 return -1; |
355 | 5117 } |
5118 s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */ | |
0 | 5119 |
355 | 5120 if (get_bits1(&s->gb) != 1) { |
5121 fprintf(stderr, "Bad marker\n"); | |
0 | 5122 return -1; /* marker */ |
355 | 5123 } |
5124 if (get_bits1(&s->gb) != 0) { | |
5125 fprintf(stderr, "Bad H263 id\n"); | |
0 | 5126 return -1; /* h263 id */ |
355 | 5127 } |
21 | 5128 skip_bits1(&s->gb); /* split screen off */ |
5129 skip_bits1(&s->gb); /* camera off */ | |
5130 skip_bits1(&s->gb); /* freeze picture release off */ | |
0 | 5131 |
5132 format = get_bits(&s->gb, 3); | |
355 | 5133 if (format != 7) { |
5134 fprintf(stderr, "Intel H263 free format not supported\n"); | |
0 | 5135 return -1; |
355 | 5136 } |
0 | 5137 s->h263_plus = 0; |
5138 | |
21 | 5139 s->pict_type = I_TYPE + get_bits1(&s->gb); |
0 | 5140 |
21 | 5141 s->unrestricted_mv = get_bits1(&s->gb); |
0 | 5142 s->h263_long_vectors = s->unrestricted_mv; |
5143 | |
355 | 5144 if (get_bits1(&s->gb) != 0) { |
5145 fprintf(stderr, "SAC not supported\n"); | |
0 | 5146 return -1; /* SAC: off */ |
355 | 5147 } |
5148 if (get_bits1(&s->gb) != 0) { | |
5149 fprintf(stderr, "Advanced Prediction Mode not supported\n"); | |
0 | 5150 return -1; /* advanced prediction mode: off */ |
355 | 5151 } |
5152 if (get_bits1(&s->gb) != 0) { | |
5153 fprintf(stderr, "PB frame mode no supported\n"); | |
5154 return -1; /* PB frame mode */ | |
5155 } | |
0 | 5156 |
5157 /* skip unknown header garbage */ | |
21 | 5158 skip_bits(&s->gb, 41); |
0 | 5159 |
5160 s->qscale = get_bits(&s->gb, 5); | |
21 | 5161 skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */ |
0 | 5162 |
5163 /* PEI */ | |
21 | 5164 while (get_bits1(&s->gb) != 0) { |
5165 skip_bits(&s->gb, 8); | |
0 | 5166 } |
5167 s->f_code = 1; | |
770
d1770a34e4f6
segfault fix patch by (Juergen Keil <jk at tools dot de>)
michaelni
parents:
766
diff
changeset
|
5168 |
d1770a34e4f6
segfault fix patch by (Juergen Keil <jk at tools dot de>)
michaelni
parents:
766
diff
changeset
|
5169 s->y_dc_scale_table= |
d1770a34e4f6
segfault fix patch by (Juergen Keil <jk at tools dot de>)
michaelni
parents:
766
diff
changeset
|
5170 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
|
5171 |
0 | 5172 return 0; |
5173 } | |
144 | 5174 |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5175 int flv_h263_decode_picture_header(MpegEncContext *s) |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5176 { |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5177 int format, width, height; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5178 |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5179 /* picture header */ |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5180 if (get_bits_long(&s->gb, 17) != 1) { |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5181 fprintf(stderr, "Bad picture start code\n"); |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5182 return -1; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5183 } |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5184 format = get_bits(&s->gb, 5); |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5185 if (format != 0 && format != 1) { |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5186 fprintf(stderr, "Bad picture format\n"); |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5187 return -1; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5188 } |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5189 s->h263_flv = format+1; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5190 s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */ |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5191 format = get_bits(&s->gb, 3); |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5192 switch (format) { |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5193 case 0: |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5194 width = get_bits(&s->gb, 8); |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5195 height = get_bits(&s->gb, 8); |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5196 break; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5197 case 1: |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5198 width = get_bits(&s->gb, 16); |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5199 height = get_bits(&s->gb, 16); |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5200 break; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5201 case 2: |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5202 width = 352; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5203 height = 288; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5204 break; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5205 case 3: |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5206 width = 176; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5207 height = 144; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5208 break; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5209 case 4: |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5210 width = 128; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5211 height = 96; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5212 break; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5213 case 5: |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5214 width = 320; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5215 height = 240; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5216 break; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5217 case 6: |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5218 width = 160; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5219 height = 120; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5220 break; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5221 default: |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5222 width = height = 0; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5223 break; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5224 } |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5225 if ((width == 0) || (height == 0)) |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5226 return -1; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5227 s->width = width; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5228 s->height = height; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5229 |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5230 s->pict_type = I_TYPE + get_bits(&s->gb, 2); |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5231 if (s->pict_type > P_TYPE) |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5232 s->pict_type = P_TYPE; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5233 skip_bits1(&s->gb); /* deblocking flag */ |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5234 s->qscale = get_bits(&s->gb, 5); |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5235 |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5236 s->h263_plus = 0; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5237 |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5238 s->unrestricted_mv = 1; |
1364 | 5239 s->h263_long_vectors = 0; |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5240 |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5241 /* PEI */ |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5242 while (get_bits1(&s->gb) != 0) { |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5243 skip_bits(&s->gb, 8); |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5244 } |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5245 s->f_code = 1; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5246 |
1364 | 5247 if(s->avctx->debug & FF_DEBUG_PICT_INFO){ |
5248 printf("%c esc_type:%d, qp:%d num:%d\n", | |
5249 av_get_pict_type_char(s->pict_type), s->h263_flv-1, s->qscale, s->picture_number); | |
5250 } | |
5251 | |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5252 s->y_dc_scale_table= |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5253 s->c_dc_scale_table= ff_mpeg1_dc_scale_table; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5254 |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5255 return 0; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5256 } |