Mercurial > libavcodec.hg
annotate h263.c @ 1671:a75cbb4588d1 libavcodec
100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l
author | michael |
---|---|
date | Tue, 09 Dec 2003 14:03:55 +0000 |
parents | d6f2520c0c43 |
children | 6bd7a01eca9c |
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 | |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
32 #include <limits.h> |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
33 |
0 | 34 #include "common.h" |
35 #include "dsputil.h" | |
36 #include "avcodec.h" | |
37 #include "mpegvideo.h" | |
38 #include "h263data.h" | |
39 #include "mpeg4data.h" | |
40 | |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
41 //#undef NDEBUG |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
42 //#include <assert.h> |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
43 |
544 | 44 #define INTRA_MCBPC_VLC_BITS 6 |
1482 | 45 #define INTER_MCBPC_VLC_BITS 7 |
544 | 46 #define CBPY_VLC_BITS 6 |
47 #define MV_VLC_BITS 9 | |
48 #define DC_VLC_BITS 9 | |
49 #define SPRITE_TRAJ_VLC_BITS 6 | |
50 #define MB_TYPE_B_VLC_BITS 4 | |
51 #define TEX_VLC_BITS 9 | |
1655 | 52 #define H263_MBTYPE_B_VLC_BITS 6 |
53 #define CBPC_B_VLC_BITS 3 | |
544 | 54 |
815
78accc54493b
put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents:
770
diff
changeset
|
55 #ifdef CONFIG_ENCODERS |
0 | 56 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
|
57 int n); |
324 | 58 static void h263_encode_motion(MpegEncContext * s, int val, int fcode); |
78 | 59 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
|
60 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
|
61 int n, int dc, uint8_t *scan_table, |
453 | 62 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
|
63 #endif |
78accc54493b
put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents:
770
diff
changeset
|
64 |
262 | 65 static int h263_decode_motion(MpegEncContext * s, int pred, int fcode); |
78 | 66 static int h263p_decode_umotion(MpegEncContext * s, int pred); |
0 | 67 static int h263_decode_block(MpegEncContext * s, DCTELEM * block, |
68 int n, int coded); | |
453 | 69 static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr); |
70 static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block, | |
1132 | 71 int n, int coded, int intra, int rvlc); |
1064 | 72 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
|
73 #ifdef CONFIG_ENCODERS |
1424 | 74 static void mpeg4_encode_visual_object_header(MpegEncContext * s); |
75 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
|
76 #endif //CONFIG_ENCODERS |
290 | 77 static void mpeg4_decode_sprite_trajectory(MpegEncContext * s); |
1064 | 78 static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, uint16_t **dc_val_ptr, int *dir_ptr); |
79 | |
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
|
80 #ifdef CONFIG_ENCODERS |
1064 | 81 static uint8_t uni_DCtab_lum_len[512]; |
82 static uint8_t uni_DCtab_chrom_len[512]; | |
83 static uint16_t uni_DCtab_lum_bits[512]; | |
84 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
|
85 |
1162 | 86 static uint8_t (*mv_penalty)[MAX_MV*2+1]= NULL; |
1064 | 87 static uint8_t fcode_tab[MAX_MV*2+1]; |
88 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
|
89 |
945 | 90 static uint32_t uni_mpeg4_intra_rl_bits[64*64*2*2]; |
91 static uint8_t uni_mpeg4_intra_rl_len [64*64*2*2]; | |
92 static uint32_t uni_mpeg4_inter_rl_bits[64*64*2*2]; | |
93 static uint8_t uni_mpeg4_inter_rl_len [64*64*2*2]; | |
94 //#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
|
95 //#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run) + (level)*64) |
945 | 96 #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
|
97 |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream 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 /* 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
|
99 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
|
100 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
|
101 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
|
102 |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream 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 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
|
104 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
|
105 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
|
106 */ |
815
78accc54493b
put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents:
770
diff
changeset
|
107 #endif |
78accc54493b
put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents:
770
diff
changeset
|
108 |
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
|
109 #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
|
110 #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
|
111 #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
|
112 #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
|
113 #endif |
293 | 114 |
0 | 115 int h263_get_picture_format(int width, int height) |
116 { | |
117 int format; | |
118 | |
119 if (width == 128 && height == 96) | |
355 | 120 format = 1; |
0 | 121 else if (width == 176 && height == 144) |
355 | 122 format = 2; |
0 | 123 else if (width == 352 && height == 288) |
355 | 124 format = 3; |
0 | 125 else if (width == 704 && height == 576) |
355 | 126 format = 4; |
0 | 127 else if (width == 1408 && height == 1152) |
355 | 128 format = 5; |
0 | 129 else |
130 format = 7; | |
131 return format; | |
132 } | |
133 | |
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
|
134 #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
|
135 |
1548 | 136 static void aspect_to_info(MpegEncContext * s, AVRational aspect){ |
887 | 137 int i; |
138 | |
1548 | 139 if(aspect.num==0) aspect= (AVRational){1,1}; |
140 | |
887 | 141 for(i=1; i<6; i++){ |
1548 | 142 if(av_cmp_q(pixel_aspect[i], aspect) == 0){ |
887 | 143 s->aspect_ratio_info=i; |
144 return; | |
145 } | |
146 } | |
880 | 147 |
887 | 148 s->aspect_ratio_info= FF_ASPECT_EXTENDED; |
880 | 149 } |
150 | |
1354 | 151 void ff_flv_encode_picture_header(MpegEncContext * s, int picture_number) |
0 | 152 { |
1354 | 153 int format; |
154 | |
155 align_put_bits(&s->pb); | |
156 | |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
157 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
|
158 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
|
159 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
|
160 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
|
161 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
|
162 format = 2; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
163 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
|
164 format = 3; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
165 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
|
166 format = 4; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
167 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
|
168 format = 5; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
169 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
|
170 format = 6; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
171 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
|
172 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
|
173 else |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
174 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
|
175 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
|
176 if (format == 0) { |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
177 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
|
178 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
|
179 } else if (format == 1) { |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
180 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
|
181 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
|
182 } |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
183 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
|
184 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
|
185 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
|
186 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
|
187 |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
188 if(s->h263_aic){ |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
189 s->y_dc_scale_table= |
1639 | 190 s->c_dc_scale_table= ff_aic_dc_scale_table; |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
191 }else{ |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
192 s->y_dc_scale_table= |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
193 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
|
194 } |
1354 | 195 } |
196 | |
197 void h263_encode_picture_header(MpegEncContext * s, int picture_number) | |
198 { | |
199 int format; | |
200 | |
201 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
|
202 |
231 | 203 /* 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
|
204 s->ptr_lastgob = pbBufPtr(&s->pb); |
231 | 205 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
|
206 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
|
207 s->avctx->frame_rate) & 0xff); |
0 | 208 |
209 put_bits(&s->pb, 1, 1); /* marker */ | |
210 put_bits(&s->pb, 1, 0); /* h263 id */ | |
211 put_bits(&s->pb, 1, 0); /* split screen off */ | |
212 put_bits(&s->pb, 1, 0); /* camera off */ | |
213 put_bits(&s->pb, 1, 0); /* freeze picture release off */ | |
78 | 214 |
215 format = h263_get_picture_format(s->width, s->height); | |
0 | 216 if (!s->h263_plus) { |
217 /* H.263v1 */ | |
218 put_bits(&s->pb, 3, format); | |
219 put_bits(&s->pb, 1, (s->pict_type == P_TYPE)); | |
220 /* By now UMV IS DISABLED ON H.263v1, since the restrictions | |
221 of H.263v1 UMV implies to check the predicted MV after | |
222 calculation of the current MB to see if we're on the limits */ | |
223 put_bits(&s->pb, 1, 0); /* unrestricted motion vector: off */ | |
224 put_bits(&s->pb, 1, 0); /* SAC: off */ | |
1633 | 225 put_bits(&s->pb, 1, s->obmc); /* advanced prediction mode */ |
0 | 226 put_bits(&s->pb, 1, 0); /* not PB frame */ |
227 put_bits(&s->pb, 5, s->qscale); | |
228 put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */ | |
229 } else { | |
230 /* H.263v2 */ | |
231 /* H.263 Plus PTYPE */ | |
232 put_bits(&s->pb, 3, 7); | |
233 put_bits(&s->pb,3,1); /* Update Full Extended PTYPE */ | |
78 | 234 if (format == 7) |
235 put_bits(&s->pb,3,6); /* Custom Source Format */ | |
236 else | |
237 put_bits(&s->pb, 3, format); | |
238 | |
0 | 239 put_bits(&s->pb,1,0); /* Custom PCF: off */ |
1661 | 240 put_bits(&s->pb,1, s->umvplus); /* Unrestricted Motion Vector */ |
0 | 241 put_bits(&s->pb,1,0); /* SAC: off */ |
1633 | 242 put_bits(&s->pb,1,s->obmc); /* Advanced Prediction Mode */ |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
243 put_bits(&s->pb,1,s->h263_aic); /* Advanced Intra Coding */ |
1644 | 244 put_bits(&s->pb,1,s->loop_filter); /* Deblocking Filter */ |
1661 | 245 put_bits(&s->pb,1,s->h263_slice_structured); /* Slice Structured */ |
0 | 246 put_bits(&s->pb,1,0); /* Reference Picture Selection: off */ |
247 put_bits(&s->pb,1,0); /* Independent Segment Decoding: off */ | |
1637 | 248 put_bits(&s->pb,1,s->alt_inter_vlc); /* Alternative Inter VLC */ |
1644 | 249 put_bits(&s->pb,1,s->modified_quant); /* Modified Quantization: */ |
0 | 250 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */ |
251 put_bits(&s->pb,3,0); /* Reserved */ | |
252 | |
253 put_bits(&s->pb, 3, s->pict_type == P_TYPE); | |
254 | |
255 put_bits(&s->pb,1,0); /* Reference Picture Resampling: off */ | |
256 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
|
257 put_bits(&s->pb,1,s->no_rounding); /* Rounding Type */ |
0 | 258 put_bits(&s->pb,2,0); /* Reserved */ |
259 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */ | |
260 | |
261 /* This should be here if PLUSPTYPE */ | |
262 put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */ | |
263 | |
78 | 264 if (format == 7) { |
265 /* Custom Picture Format (CPFMT) */ | |
1548 | 266 aspect_to_info(s, s->avctx->sample_aspect_ratio); |
880 | 267 |
268 put_bits(&s->pb,4,s->aspect_ratio_info); | |
78 | 269 put_bits(&s->pb,9,(s->width >> 2) - 1); |
270 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */ | |
271 put_bits(&s->pb,9,(s->height >> 2)); | |
1548 | 272 if (s->aspect_ratio_info == FF_ASPECT_EXTENDED){ |
273 put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.num); | |
274 put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.den); | |
669
b4bddbde44f3
aspect (ext. par too) support for h263 and mpeg4 (inc. build becouse of new vars)
al3x
parents:
667
diff
changeset
|
275 } |
78 | 276 } |
277 | |
0 | 278 /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */ |
79
82e579c37bc3
Moved some H.263+ variables to MpegEncContext to be thread-safe.
pulento
parents:
78
diff
changeset
|
279 if (s->umvplus) |
1089 | 280 // put_bits(&s->pb,1,1); /* Limited according tables of Annex D */ |
1644 | 281 //FIXME check actual requested range |
1089 | 282 put_bits(&s->pb,2,1); /* unlimited */ |
1661 | 283 if(s->h263_slice_structured) |
284 put_bits(&s->pb,2,0); /* no weird submodes */ | |
1089 | 285 |
0 | 286 put_bits(&s->pb, 5, s->qscale); |
287 } | |
288 | |
289 put_bits(&s->pb, 1, 0); /* no PEI */ | |
498 | 290 |
1670 | 291 if(s->h263_slice_structured){ |
292 put_bits(&s->pb, 1, 1); | |
293 | |
294 assert(s->mb_x == 0 && s->mb_y == 0); | |
295 ff_h263_encode_mba(s); | |
296 | |
297 put_bits(&s->pb, 1, 1); | |
298 } | |
299 | |
498 | 300 if(s->h263_aic){ |
301 s->y_dc_scale_table= | |
1639 | 302 s->c_dc_scale_table= ff_aic_dc_scale_table; |
498 | 303 }else{ |
304 s->y_dc_scale_table= | |
305 s->c_dc_scale_table= ff_mpeg1_dc_scale_table; | |
306 } | |
0 | 307 } |
308 | |
766 | 309 /** |
310 * Encodes a group of blocks header. | |
311 */ | |
1661 | 312 void h263_encode_gob_header(MpegEncContext * s, int mb_line) |
162 | 313 { |
1661 | 314 put_bits(&s->pb, 17, 1); /* GBSC */ |
315 | |
316 if(s->h263_slice_structured){ | |
317 put_bits(&s->pb, 1, 1); | |
318 | |
319 ff_h263_encode_mba(s); | |
320 | |
321 if(s->mb_num > 1583) | |
322 put_bits(&s->pb, 1, 1); | |
323 put_bits(&s->pb, 5, s->qscale); /* GQUANT */ | |
324 put_bits(&s->pb, 1, 1); | |
325 put_bits(&s->pb, 2, s->pict_type == I_TYPE); /* GFID */ | |
326 }else{ | |
327 int gob_number= mb_line / s->gob_index; | |
328 | |
329 put_bits(&s->pb, 5, gob_number); /* GN */ | |
330 put_bits(&s->pb, 2, s->pict_type == I_TYPE); /* GFID */ | |
331 put_bits(&s->pb, 5, s->qscale); /* GQUANT */ | |
332 } | |
162 | 333 } |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
334 |
1492 | 335 static inline int get_block_rate(MpegEncContext * s, DCTELEM block[64], int block_last_index, uint8_t scantable[64]){ |
336 int last=0; | |
337 int j; | |
338 int rate=0; | |
339 | |
340 for(j=1; j<=block_last_index; j++){ | |
341 const int index= scantable[j]; | |
342 int level= block[index]; | |
343 if(level){ | |
344 level+= 64; | |
345 if((level&(~127)) == 0){ | |
346 if(j<block_last_index) rate+= s->intra_ac_vlc_length [UNI_AC_ENC_INDEX(j-last-1, level)]; | |
347 else rate+= s->intra_ac_vlc_last_length[UNI_AC_ENC_INDEX(j-last-1, level)]; | |
348 }else | |
349 rate += s->ac_esc_length; | |
350 level-= 64; | |
351 | |
352 last= j; | |
353 } | |
354 } | |
355 | |
356 return rate; | |
357 } | |
358 | |
359 static inline int decide_ac_pred(MpegEncContext * s, DCTELEM block[6][64], int dir[6], uint8_t *st[6], int zigzag_last_index[6]) | |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
360 { |
1492 | 361 int score= 0; |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
362 int i, n; |
903 | 363 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
|
364 |
1492 | 365 memcpy(zigzag_last_index, s->block_last_index, sizeof(int)*6); |
366 | |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
367 for(n=0; n<6; n++){ |
1064 | 368 int16_t *ac_val, *ac_val1; |
1492 | 369 |
370 score -= get_block_rate(s, block[n], s->block_last_index[n], s->intra_scantable.permutated); | |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
371 |
266 | 372 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
|
373 ac_val1= ac_val; |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
374 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
|
375 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
|
376 /* top prediction */ |
266 | 377 ac_val-= s->block_wrap[n]*16; |
903 | 378 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
|
379 /* same qscale */ |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
380 for(i=1; i<8; i++){ |
1092 | 381 const int level= block[n][s->dsp.idct_permutation[i ]]; |
1492 | 382 block[n][s->dsp.idct_permutation[i ]] = level - ac_val[i+8]; |
1092 | 383 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
|
384 ac_val1[i+8]= level; |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
385 } |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
386 }else{ |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
387 /* different qscale, we must rescale */ |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
388 for(i=1; i<8; i++){ |
1092 | 389 const int level= block[n][s->dsp.idct_permutation[i ]]; |
1492 | 390 block[n][s->dsp.idct_permutation[i ]] = level - ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale); |
1092 | 391 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
|
392 ac_val1[i+8]= level; |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
393 } |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
394 } |
1492 | 395 st[n]= s->intra_h_scantable.permutated; |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
396 }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
|
397 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
|
398 /* left prediction */ |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
399 ac_val-= 16; |
903 | 400 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
|
401 /* same qscale */ |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
402 for(i=1; i<8; i++){ |
1092 | 403 const int level= block[n][s->dsp.idct_permutation[i<<3]]; |
1492 | 404 block[n][s->dsp.idct_permutation[i<<3]]= level - ac_val[i]; |
692
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
405 ac_val1[i ]= level; |
1092 | 406 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
|
407 } |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
408 }else{ |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
409 /* different qscale, we must rescale */ |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
410 for(i=1; i<8; i++){ |
1092 | 411 const int level= block[n][s->dsp.idct_permutation[i<<3]]; |
1492 | 412 block[n][s->dsp.idct_permutation[i<<3]]= 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
|
413 ac_val1[i ]= level; |
1092 | 414 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
|
415 } |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
416 } |
1492 | 417 st[n]= s->intra_v_scantable.permutated; |
418 } | |
419 | |
420 for(i=63; i>0; i--) //FIXME optimize | |
421 if(block[n][ st[n][i] ]) break; | |
422 s->block_last_index[n]= i; | |
423 | |
424 score += get_block_rate(s, block[n], s->block_last_index[n], st[n]); | |
425 } | |
426 | |
427 return score < 0; | |
428 } | |
429 | |
430 static inline void restore_ac_coeffs(MpegEncContext * s, DCTELEM block[6][64], int dir[6], uint8_t *st[6], int zigzag_last_index[6]) | |
431 { | |
432 int i, n; | |
433 memcpy(s->block_last_index, zigzag_last_index, sizeof(int)*6); | |
434 | |
435 for(n=0; n<6; n++){ | |
436 int16_t *ac_val = s->ac_val[0][0] + s->block_index[n] * 16; | |
437 | |
438 st[n]= s->intra_scantable.permutated; | |
439 if(dir[n]){ | |
440 /* top prediction */ | |
441 for(i=1; i<8; i++){ | |
442 block[n][s->dsp.idct_permutation[i ]] = ac_val[i+8]; | |
443 } | |
444 }else{ | |
445 /* left prediction */ | |
446 for(i=1; i<8; i++){ | |
447 block[n][s->dsp.idct_permutation[i<<3]]= ac_val[i ]; | |
448 } | |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
449 } |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
450 } |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
451 } |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
452 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
453 /** |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
454 * 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
|
455 */ |
695 | 456 void ff_clean_h263_qscales(MpegEncContext *s){ |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
457 int i; |
903 | 458 int8_t * const qscale_table= s->current_picture.qscale_table; |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
459 |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
460 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
|
461 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
|
462 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
|
463 } |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
464 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
|
465 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
|
466 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
|
467 } |
695 | 468 } |
469 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
470 /** |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
471 * 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
|
472 */ |
695 | 473 void ff_clean_mpeg4_qscales(MpegEncContext *s){ |
474 int i; | |
903 | 475 int8_t * const qscale_table= s->current_picture.qscale_table; |
476 | |
695 | 477 ff_clean_h263_qscales(s); |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
478 |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
479 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
|
480 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
|
481 |
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 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
|
483 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
|
484 s->mb_type[mb_xy]|= MB_TYPE_INTER; |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
485 } |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
486 } |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
487 |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
488 if(s->pict_type== B_TYPE){ |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
489 int odd=0; |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
490 /* 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
|
491 for the actual adaptive quantization */ |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
492 |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
493 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
|
494 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
|
495 odd += qscale_table[mb_xy]&1; |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
496 } |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
497 |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
498 if(2*odd > s->mb_num) odd=1; |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
499 else odd=0; |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
500 |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
501 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
|
502 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
|
503 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
|
504 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
|
505 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
|
506 qscale_table[mb_xy]= 31; |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
507 } |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
508 |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
509 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
|
510 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
|
511 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
|
512 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
|
513 s->mb_type[mb_xy]|= MB_TYPE_BIDIR; |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
514 } |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
515 } |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
516 } |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
517 } |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
518 |
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
|
519 #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
|
520 /** |
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
|
521 * |
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
|
522 * @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
|
523 */ |
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
|
524 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
|
525 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
|
526 const int colocated_mb_type= s->next_picture.mb_type[mb_index]; //FIXME or next? |
936 | 527 int xy= s->block_index[0]; |
528 uint16_t time_pp= s->pp_time; | |
529 uint16_t time_pb= s->pb_time; | |
530 int i; | |
1053
f07fd48c23d4
direct blocksize in bframes fix (might fix qpel+bframe bug)
michaelni
parents:
1042
diff
changeset
|
531 |
936 | 532 //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
|
533 |
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
|
534 if(IS_8X8(colocated_mb_type)){ |
936 | 535 s->mv_type = MV_TYPE_8X8; |
536 for(i=0; i<4; i++){ | |
537 xy= s->block_index[i]; | |
1668
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1666
diff
changeset
|
538 s->mv[0][i][0] = s->next_picture.motion_val[0][xy][0]*time_pb/time_pp + mx; |
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1666
diff
changeset
|
539 s->mv[0][i][1] = s->next_picture.motion_val[0][xy][1]*time_pb/time_pp + my; |
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1666
diff
changeset
|
540 s->mv[1][i][0] = mx ? s->mv[0][i][0] - s->next_picture.motion_val[0][xy][0] |
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1666
diff
changeset
|
541 : s->next_picture.motion_val[0][xy][0]*(time_pb - time_pp)/time_pp; |
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1666
diff
changeset
|
542 s->mv[1][i][1] = my ? s->mv[0][i][1] - s->next_picture.motion_val[0][xy][1] |
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1666
diff
changeset
|
543 : s->next_picture.motion_val[0][xy][1]*(time_pb - time_pp)/time_pp; |
936 | 544 } |
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
|
545 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
|
546 } else if(IS_INTERLACED(colocated_mb_type)){ |
936 | 547 s->mv_type = MV_TYPE_FIELD; |
548 for(i=0; i<2; i++){ | |
549 if(s->top_field_first){ | |
550 time_pp= s->pp_field_time - s->field_select_table[mb_index][i] + i; | |
551 time_pb= s->pb_field_time - s->field_select_table[mb_index][i] + i; | |
552 }else{ | |
553 time_pp= s->pp_field_time + s->field_select_table[mb_index][i] - i; | |
554 time_pb= s->pb_field_time + s->field_select_table[mb_index][i] - i; | |
555 } | |
556 s->mv[0][i][0] = s->field_mv_table[mb_index][i][0]*time_pb/time_pp + mx; | |
557 s->mv[0][i][1] = s->field_mv_table[mb_index][i][1]*time_pb/time_pp + my; | |
558 s->mv[1][i][0] = mx ? s->mv[0][i][0] - s->field_mv_table[mb_index][i][0] | |
559 : s->field_mv_table[mb_index][i][0]*(time_pb - time_pp)/time_pp; | |
560 s->mv[1][i][1] = my ? s->mv[0][i][1] - s->field_mv_table[mb_index][i][1] | |
561 : s->field_mv_table[mb_index][i][1]*(time_pb - time_pp)/time_pp; | |
562 } | |
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
|
563 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
|
564 }else{ |
1668
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1666
diff
changeset
|
565 s->mv[0][0][0] = s->mv[0][1][0] = s->mv[0][2][0] = s->mv[0][3][0] = s->next_picture.motion_val[0][xy][0]*time_pb/time_pp + mx; |
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1666
diff
changeset
|
566 s->mv[0][0][1] = s->mv[0][1][1] = s->mv[0][2][1] = s->mv[0][3][1] = s->next_picture.motion_val[0][xy][1]*time_pb/time_pp + my; |
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1666
diff
changeset
|
567 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->next_picture.motion_val[0][xy][0] |
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1666
diff
changeset
|
568 : s->next_picture.motion_val[0][xy][0]*(time_pb - time_pp)/time_pp; |
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1666
diff
changeset
|
569 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->next_picture.motion_val[0][xy][1] |
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1666
diff
changeset
|
570 : s->next_picture.motion_val[0][xy][1]*(time_pb - time_pp)/time_pp; |
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
|
571 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
|
572 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
|
573 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
|
574 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
|
575 return MB_TYPE_DIRECT2 | MB_TYPE_16x16 | MB_TYPE_L0L1; //Note see prev line |
936 | 576 } |
577 } | |
578 | |
1389 | 579 void ff_h263_update_motion_val(MpegEncContext * s){ |
580 const int mb_xy = s->mb_y * s->mb_stride + s->mb_x; | |
581 //FIXME a lot of thet is only needed for !low_delay | |
582 const int wrap = s->block_wrap[0]; | |
583 const int xy = s->block_index[0]; | |
584 | |
585 s->current_picture.mbskip_table[mb_xy]= s->mb_skiped; | |
586 | |
587 if(s->mv_type != MV_TYPE_8X8){ | |
588 int motion_x, motion_y; | |
589 if (s->mb_intra) { | |
590 motion_x = 0; | |
591 motion_y = 0; | |
592 } else if (s->mv_type == MV_TYPE_16X16) { | |
593 motion_x = s->mv[0][0][0]; | |
594 motion_y = s->mv[0][0][1]; | |
595 } else /*if (s->mv_type == MV_TYPE_FIELD)*/ { | |
596 int i; | |
597 motion_x = s->mv[0][0][0] + s->mv[0][1][0]; | |
598 motion_y = s->mv[0][0][1] + s->mv[0][1][1]; | |
599 motion_x = (motion_x>>1) | (motion_x&1); | |
600 for(i=0; i<2; i++){ | |
601 s->field_mv_table[mb_xy][i][0]= s->mv[0][i][0]; | |
602 s->field_mv_table[mb_xy][i][1]= s->mv[0][i][1]; | |
603 s->field_select_table[mb_xy][i]= s->field_select[0][i]; | |
604 } | |
605 } | |
606 | |
607 /* no update if 8X8 because it has been done during parsing */ | |
1668
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1666
diff
changeset
|
608 s->current_picture.motion_val[0][xy][0] = motion_x; |
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1666
diff
changeset
|
609 s->current_picture.motion_val[0][xy][1] = motion_y; |
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1666
diff
changeset
|
610 s->current_picture.motion_val[0][xy + 1][0] = motion_x; |
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1666
diff
changeset
|
611 s->current_picture.motion_val[0][xy + 1][1] = motion_y; |
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1666
diff
changeset
|
612 s->current_picture.motion_val[0][xy + wrap][0] = motion_x; |
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1666
diff
changeset
|
613 s->current_picture.motion_val[0][xy + wrap][1] = motion_y; |
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1666
diff
changeset
|
614 s->current_picture.motion_val[0][xy + 1 + wrap][0] = motion_x; |
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1666
diff
changeset
|
615 s->current_picture.motion_val[0][xy + 1 + wrap][1] = motion_y; |
1389 | 616 } |
617 | |
618 if(s->encoding){ //FIXME encoding MUST be cleaned up | |
619 if (s->mv_type == MV_TYPE_8X8) | |
620 s->current_picture.mb_type[mb_xy]= MB_TYPE_L0 | MB_TYPE_8x8; | |
1633 | 621 else if(s->mb_intra) |
622 s->current_picture.mb_type[mb_xy]= MB_TYPE_INTRA; | |
1389 | 623 else |
624 s->current_picture.mb_type[mb_xy]= MB_TYPE_L0 | MB_TYPE_16x16; | |
625 } | |
626 } | |
627 | |
815
78accc54493b
put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents:
770
diff
changeset
|
628 #ifdef CONFIG_ENCODERS |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
629 |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
630 static inline int get_p_cbp(MpegEncContext * s, |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
631 DCTELEM block[6][64], |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
632 int motion_x, int motion_y){ |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
633 int cbp, i; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
634 |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
635 if(s->flags & CODEC_FLAG_CBP_RD){ |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
636 int best_cbpy_score= INT_MAX; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
637 int best_cbpc_score= INT_MAX; |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
638 int cbpc = (-1), cbpy= (-1); |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
639 const int offset= (s->mv_type==MV_TYPE_16X16 ? 0 : 16) + (s->dquant ? 8 : 0); |
1505
010f76d07a27
use lagrange multipler instead of qp for ratecontrol, this may break some things, tell me ASAP if u notice anything broken
michaelni
parents:
1492
diff
changeset
|
640 const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6); |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
641 |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
642 for(i=0; i<4; i++){ |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
643 int score= inter_MCBPC_bits[i + offset] * lambda; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
644 if(i&1) score += s->coded_score[5]; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
645 if(i&2) score += s->coded_score[4]; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
646 |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
647 if(score < best_cbpc_score){ |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
648 best_cbpc_score= score; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
649 cbpc= i; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
650 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
651 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
652 |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
653 for(i=0; i<16; i++){ |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
654 int score= cbpy_tab[i ^ 0xF][1] * lambda; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
655 if(i&1) score += s->coded_score[3]; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
656 if(i&2) score += s->coded_score[2]; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
657 if(i&4) score += s->coded_score[1]; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
658 if(i&8) score += s->coded_score[0]; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
659 |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
660 if(score < best_cbpy_score){ |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
661 best_cbpy_score= score; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
662 cbpy= i; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
663 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
664 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
665 cbp= cbpc + 4*cbpy; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
666 if ((motion_x | motion_y | s->dquant) == 0 && s->mv_type==MV_TYPE_16X16){ |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
667 if(best_cbpy_score + best_cbpc_score + 2*lambda >= 0) |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
668 cbp= 0; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
669 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
670 |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
671 for (i = 0; i < 6; i++) { |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
672 if (s->block_last_index[i] >= 0 && ((cbp >> (5 - i))&1)==0 ){ |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
673 s->block_last_index[i]= -1; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
674 memset(s->block[i], 0, sizeof(DCTELEM)*64); |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
675 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
676 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
677 }else{ |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
678 cbp= 0; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
679 for (i = 0; i < 6; i++) { |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
680 if (s->block_last_index[i] >= 0) |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
681 cbp |= 1 << (5 - i); |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
682 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
683 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
684 return cbp; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
685 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
686 |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
687 static inline int get_b_cbp(MpegEncContext * s, DCTELEM block[6][64], |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
688 int motion_x, int motion_y, int mb_type){ |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
689 int cbp=0, i; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
690 |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
691 if(s->flags & CODEC_FLAG_CBP_RD){ |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
692 int score=0; |
1505
010f76d07a27
use lagrange multipler instead of qp for ratecontrol, this may break some things, tell me ASAP if u notice anything broken
michaelni
parents:
1492
diff
changeset
|
693 const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6); |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
694 |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
695 for(i=0; i<6; i++){ |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
696 if(s->coded_score[i] < 0){ |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
697 score += s->coded_score[i]; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
698 cbp |= 1 << (5 - i); |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
699 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
700 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
701 |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
702 if(cbp){ |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
703 int zero_score= -6; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
704 if ((motion_x | motion_y | s->dquant | mb_type) == 0){ |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
705 zero_score-= 4; //2*MV + mb_type + cbp bit |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
706 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
707 |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
708 zero_score*= lambda; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
709 if(zero_score <= score){ |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
710 cbp=0; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
711 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
712 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
713 |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
714 for (i = 0; i < 6; i++) { |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
715 if (s->block_last_index[i] >= 0 && ((cbp >> (5 - i))&1)==0 ){ |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
716 s->block_last_index[i]= -1; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
717 memset(s->block[i], 0, sizeof(DCTELEM)*64); |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
718 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
719 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
720 }else{ |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
721 for (i = 0; i < 6; i++) { |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
722 if (s->block_last_index[i] >= 0) |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
723 cbp |= 1 << (5 - i); |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
724 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
725 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
726 return cbp; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
727 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
728 |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
729 void mpeg4_encode_mb(MpegEncContext * s, |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
730 DCTELEM block[6][64], |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
731 int motion_x, int motion_y) |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
732 { |
1057 | 733 int cbpc, cbpy, pred_x, pred_y; |
453 | 734 PutBitContext * const pb2 = s->data_partitioning ? &s->pb2 : &s->pb; |
735 PutBitContext * const tex_pb = s->data_partitioning && s->pict_type!=B_TYPE ? &s->tex_pb : &s->pb; | |
736 PutBitContext * const dc_pb = s->data_partitioning && s->pict_type!=I_TYPE ? &s->pb2 : &s->pb; | |
737 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
|
738 const int dquant_code[5]= {1,0,9,2,3}; |
162 | 739 |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
740 // 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
|
741 if (!s->mb_intra) { |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
742 int i, cbp; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
743 |
324 | 744 if(s->pict_type==B_TYPE){ |
745 static const int mb_type_table[8]= {-1, 2, 3, 1,-1,-1,-1, 0}; /* convert from mv_dir to type */ | |
746 int mb_type= mb_type_table[s->mv_dir]; | |
747 | |
748 if(s->mb_x==0){ | |
749 s->last_mv[0][0][0]= | |
750 s->last_mv[0][0][1]= | |
751 s->last_mv[1][0][0]= | |
752 s->last_mv[1][0][1]= 0; | |
753 } | |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
754 |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
755 assert(s->dquant>=-2 && s->dquant<=2); |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
756 assert((s->dquant&1)==0); |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
757 assert(mb_type>=0); |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
758 |
324 | 759 /* 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
|
760 if(s->next_picture.mbskip_table[s->mb_y * s->mb_stride + s->mb_x]){ //FIXME avoid DCT & ... |
324 | 761 s->skip_count++; |
762 s->mv[0][0][0]= | |
763 s->mv[0][0][1]= | |
764 s->mv[1][0][0]= | |
765 s->mv[1][0][1]= 0; | |
327 | 766 s->mv_dir= MV_DIR_FORWARD; //doesnt matter |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
767 s->qscale -= s->dquant; |
903 | 768 // s->mb_skiped=1; |
769 | |
324 | 770 return; |
771 } | |
936 | 772 |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
773 cbp= get_b_cbp(s, block, motion_x, motion_y, mb_type); |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
774 |
324 | 775 if ((cbp | motion_x | motion_y | mb_type) ==0) { |
776 /* direct MB with MV={0,0} */ | |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
777 assert(s->dquant==0); |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
778 |
324 | 779 put_bits(&s->pb, 1, 1); /* mb not coded modb1=1 */ |
453 | 780 |
781 if(interleaved_stats){ | |
782 s->misc_bits++; | |
783 s->last_bits++; | |
784 } | |
324 | 785 s->skip_count++; |
786 return; | |
787 } | |
903 | 788 |
324 | 789 put_bits(&s->pb, 1, 0); /* mb coded modb1=0 */ |
790 put_bits(&s->pb, 1, cbp ? 0 : 1); /* modb2 */ //FIXME merge | |
791 put_bits(&s->pb, mb_type+1, 1); // this table is so simple that we dont need it :) | |
792 if(cbp) put_bits(&s->pb, 6, cbp); | |
793 | |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
794 if(cbp && mb_type){ |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
795 if(s->dquant) |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
796 put_bits(&s->pb, 2, (s->dquant>>2)+3); |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
797 else |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
798 put_bits(&s->pb, 1, 0); |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
799 }else |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
800 s->qscale -= s->dquant; |
697 | 801 |
802 if(!s->progressive_sequence){ | |
803 if(cbp) | |
804 put_bits(&s->pb, 1, s->interlaced_dct); | |
805 if(mb_type) // not diect mode | |
806 put_bits(&s->pb, 1, 0); // no interlaced ME yet | |
807 } | |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
808 |
453 | 809 if(interleaved_stats){ |
1164 | 810 s->misc_bits+= get_bits_diff(s); |
453 | 811 } |
295 | 812 |
324 | 813 switch(mb_type) |
814 { | |
815 case 0: /* direct */ | |
816 h263_encode_motion(s, motion_x, 1); | |
817 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
|
818 s->b_count++; |
e47fa3e3f2d5
statistics for forw & back p-MBs instead of just one counter for both
michaelni
parents:
654
diff
changeset
|
819 s->f_count++; |
324 | 820 break; |
821 case 1: /* bidir */ | |
822 h263_encode_motion(s, s->mv[0][0][0] - s->last_mv[0][0][0], s->f_code); | |
823 h263_encode_motion(s, s->mv[0][0][1] - s->last_mv[0][0][1], s->f_code); | |
824 h263_encode_motion(s, s->mv[1][0][0] - s->last_mv[1][0][0], s->b_code); | |
825 h263_encode_motion(s, s->mv[1][0][1] - s->last_mv[1][0][1], s->b_code); | |
826 s->last_mv[0][0][0]= s->mv[0][0][0]; | |
827 s->last_mv[0][0][1]= s->mv[0][0][1]; | |
828 s->last_mv[1][0][0]= s->mv[1][0][0]; | |
829 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
|
830 s->b_count++; |
e47fa3e3f2d5
statistics for forw & back p-MBs instead of just one counter for both
michaelni
parents:
654
diff
changeset
|
831 s->f_count++; |
324 | 832 break; |
833 case 2: /* backward */ | |
834 h263_encode_motion(s, motion_x - s->last_mv[1][0][0], s->b_code); | |
835 h263_encode_motion(s, motion_y - s->last_mv[1][0][1], s->b_code); | |
836 s->last_mv[1][0][0]= motion_x; | |
837 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
|
838 s->b_count++; |
324 | 839 break; |
840 case 3: /* forward */ | |
841 h263_encode_motion(s, motion_x - s->last_mv[0][0][0], s->f_code); | |
842 h263_encode_motion(s, motion_y - s->last_mv[0][0][1], s->f_code); | |
843 s->last_mv[0][0][0]= motion_x; | |
844 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
|
845 s->f_count++; |
324 | 846 break; |
327 | 847 default: |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
848 av_log(s->avctx, AV_LOG_ERROR, "unknown mb type\n"); |
324 | 849 return; |
850 } | |
453 | 851 |
852 if(interleaved_stats){ | |
1164 | 853 s->mv_bits+= get_bits_diff(s); |
453 | 854 } |
295 | 855 |
324 | 856 /* encode each block */ |
857 for (i = 0; i < 6; i++) { | |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
702
diff
changeset
|
858 mpeg4_encode_block(s, block[i], i, 0, s->intra_scantable.permutated, NULL, &s->pb); |
324 | 859 } |
453 | 860 |
861 if(interleaved_stats){ | |
1164 | 862 s->p_tex_bits+= get_bits_diff(s); |
453 | 863 } |
324 | 864 }else{ /* s->pict_type==B_TYPE */ |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
865 cbp= get_p_cbp(s, block, motion_x, motion_y); |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
866 |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
867 if ((cbp | motion_x | motion_y | s->dquant) == 0 && s->mv_type==MV_TYPE_16X16) { |
331 | 868 /* check if the B frames can skip it too, as we must skip it if we skip here |
869 why didnt they just compress the skip-mb bits instead of reusing them ?! */ | |
870 if(s->max_b_frames>0){ | |
871 int i; | |
364
6b6332e7008a
segfault fix for b-frame encoding with height%16!=0
michaelni
parents:
360
diff
changeset
|
872 int x,y, offset; |
6b6332e7008a
segfault fix for b-frame encoding with height%16!=0
michaelni
parents:
360
diff
changeset
|
873 uint8_t *p_pic; |
6b6332e7008a
segfault fix for b-frame encoding with height%16!=0
michaelni
parents:
360
diff
changeset
|
874 |
6b6332e7008a
segfault fix for b-frame encoding with height%16!=0
michaelni
parents:
360
diff
changeset
|
875 x= s->mb_x*16; |
6b6332e7008a
segfault fix for b-frame encoding with height%16!=0
michaelni
parents:
360
diff
changeset
|
876 y= s->mb_y*16; |
6b6332e7008a
segfault fix for b-frame encoding with height%16!=0
michaelni
parents:
360
diff
changeset
|
877 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
|
878 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
|
879 |
6b6332e7008a
segfault fix for b-frame encoding with height%16!=0
michaelni
parents:
360
diff
changeset
|
880 offset= x + y*s->linesize; |
903 | 881 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
|
882 |
331 | 883 s->mb_skiped=1; |
884 for(i=0; i<s->max_b_frames; i++){ | |
339 | 885 uint8_t *b_pic; |
886 int diff; | |
903 | 887 Picture *pic= s->reordered_input_picture[i+1]; |
888 | |
889 if(pic==NULL || pic->pict_type!=B_TYPE) break; | |
890 | |
891 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
|
892 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
|
893 if(diff>s->qscale*70){ //FIXME check that 70 is optimal |
331 | 894 s->mb_skiped=0; |
895 break; | |
896 } | |
897 } | |
898 }else | |
899 s->mb_skiped=1; | |
900 | |
901 if(s->mb_skiped==1){ | |
902 /* skip macroblock */ | |
903 put_bits(&s->pb, 1, 1); | |
453 | 904 |
905 if(interleaved_stats){ | |
906 s->misc_bits++; | |
907 s->last_bits++; | |
908 } | |
331 | 909 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
|
910 |
331 | 911 return; |
912 } | |
295 | 913 } |
364
6b6332e7008a
segfault fix for b-frame encoding with height%16!=0
michaelni
parents:
360
diff
changeset
|
914 |
324 | 915 put_bits(&s->pb, 1, 0); /* mb coded */ |
1633 | 916 cbpc = cbp & 3; |
917 cbpy = cbp >> 2; | |
918 cbpy ^= 0xf; | |
324 | 919 if(s->mv_type==MV_TYPE_16X16){ |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
920 if(s->dquant) cbpc+= 8; |
324 | 921 put_bits(&s->pb, |
922 inter_MCBPC_bits[cbpc], | |
923 inter_MCBPC_code[cbpc]); | |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
924 |
453 | 925 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
|
926 if(s->dquant) |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
927 put_bits(pb2, 2, dquant_code[s->dquant+2]); |
697 | 928 |
929 if(!s->progressive_sequence){ | |
930 if(cbp) | |
931 put_bits(pb2, 1, s->interlaced_dct); | |
932 put_bits(pb2, 1, 0); // no interlaced ME yet | |
933 } | |
324 | 934 |
453 | 935 if(interleaved_stats){ |
1164 | 936 s->misc_bits+= get_bits_diff(s); |
453 | 937 } |
324 | 938 |
939 /* motion vectors: 16x16 mode */ | |
940 h263_pred_motion(s, 0, &pred_x, &pred_y); | |
941 | |
942 h263_encode_motion(s, motion_x - pred_x, s->f_code); | |
943 h263_encode_motion(s, motion_y - pred_y, s->f_code); | |
944 }else{ | |
945 put_bits(&s->pb, | |
1633 | 946 inter_MCBPC_bits[cbpc+16], |
947 inter_MCBPC_code[cbpc+16]); | |
453 | 948 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]); |
949 | |
757 | 950 if(!s->progressive_sequence){ |
951 if(cbp) | |
952 put_bits(pb2, 1, s->interlaced_dct); | |
953 } | |
954 | |
453 | 955 if(interleaved_stats){ |
1164 | 956 s->misc_bits+= get_bits_diff(s); |
453 | 957 } |
324 | 958 |
959 for(i=0; i<4; i++){ | |
960 /* motion vectors: 8x8 mode*/ | |
961 h263_pred_motion(s, i, &pred_x, &pred_y); | |
962 | |
1668
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1666
diff
changeset
|
963 h263_encode_motion(s, s->current_picture.motion_val[0][ s->block_index[i] ][0] - pred_x, s->f_code); |
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1666
diff
changeset
|
964 h263_encode_motion(s, s->current_picture.motion_val[0][ s->block_index[i] ][1] - pred_y, s->f_code); |
324 | 965 } |
966 } | |
453 | 967 |
968 if(interleaved_stats){ | |
1164 | 969 s->mv_bits+= get_bits_diff(s); |
453 | 970 } |
324 | 971 |
972 /* encode each block */ | |
973 for (i = 0; i < 6; i++) { | |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
702
diff
changeset
|
974 mpeg4_encode_block(s, block[i], i, 0, s->intra_scantable.permutated, NULL, tex_pb); |
324 | 975 } |
453 | 976 |
977 if(interleaved_stats){ | |
1164 | 978 s->p_tex_bits+= get_bits_diff(s); |
453 | 979 } |
656
e47fa3e3f2d5
statistics for forw & back p-MBs instead of just one counter for both
michaelni
parents:
654
diff
changeset
|
980 s->f_count++; |
295 | 981 } |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
982 } else { |
324 | 983 int cbp; |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
984 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
|
985 int dir[6]; //prediction direction |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
986 int zigzag_last_index[6]; |
1064 | 987 uint8_t *scan_table[6]; |
1057 | 988 int i; |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
989 |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
990 for(i=0; i<6; i++){ |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
991 const int level= block[i][0]; |
1064 | 992 uint16_t *dc_ptr; |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
993 |
498 | 994 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
|
995 if (i < 4) { |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
996 *dc_ptr = level * s->y_dc_scale; |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
997 } else { |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
998 *dc_ptr = level * s->c_dc_scale; |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
999 } |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1000 } |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1001 |
1492 | 1002 if(s->flags & CODEC_FLAG_AC_PRED){ |
1003 s->ac_pred= decide_ac_pred(s, block, dir, scan_table, zigzag_last_index); | |
1004 if(!s->ac_pred) | |
1005 restore_ac_coeffs(s, block, dir, scan_table, zigzag_last_index); | |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1006 }else{ |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1007 for(i=0; i<6; i++) |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
702
diff
changeset
|
1008 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
|
1009 } |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1010 |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1011 /* compute cbp */ |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1012 cbp = 0; |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1013 for (i = 0; i < 6; i++) { |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1014 if (s->block_last_index[i] >= 1) |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1015 cbp |= 1 << (5 - i); |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1016 } |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1017 |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1018 cbpc = cbp & 3; |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1019 if (s->pict_type == I_TYPE) { |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
1020 if(s->dquant) cbpc+=4; |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1021 put_bits(&s->pb, |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1022 intra_MCBPC_bits[cbpc], |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1023 intra_MCBPC_code[cbpc]); |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1024 } else { |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
1025 if(s->dquant) cbpc+=8; |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1026 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
|
1027 put_bits(&s->pb, |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1028 inter_MCBPC_bits[cbpc + 4], |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1029 inter_MCBPC_code[cbpc + 4]); |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1030 } |
453 | 1031 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
|
1032 cbpy = cbp >> 2; |
453 | 1033 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
|
1034 if(s->dquant) |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
1035 put_bits(dc_pb, 2, dquant_code[s->dquant+2]); |
453 | 1036 |
697 | 1037 if(!s->progressive_sequence){ |
1038 put_bits(dc_pb, 1, s->interlaced_dct); | |
1039 } | |
1040 | |
453 | 1041 if(interleaved_stats){ |
1164 | 1042 s->misc_bits+= get_bits_diff(s); |
453 | 1043 } |
286 | 1044 |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1045 /* encode each block */ |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1046 for (i = 0; i < 6; i++) { |
453 | 1047 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
|
1048 } |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1049 |
453 | 1050 if(interleaved_stats){ |
1164 | 1051 s->i_tex_bits+= get_bits_diff(s); |
453 | 1052 } |
286 | 1053 s->i_count++; |
1054 | |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1055 /* restore ac coeffs & last_index stuff if we messed them up with the prediction */ |
1492 | 1056 if(s->ac_pred) |
1057 restore_ac_coeffs(s, block, dir, scan_table, zigzag_last_index); | |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1058 } |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1059 } |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1060 |
0 | 1061 void h263_encode_mb(MpegEncContext * s, |
1062 DCTELEM block[6][64], | |
1063 int motion_x, int motion_y) | |
1064 { | |
1065 int cbpc, cbpy, i, cbp, pred_x, pred_y; | |
1064 | 1066 int16_t pred_dc; |
1067 int16_t rec_intradc[6]; | |
1068 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
|
1069 const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1); |
695 | 1070 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
|
1071 |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1072 //printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y); |
324 | 1073 if (!s->mb_intra) { |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1074 /* compute cbp */ |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
1075 cbp= get_p_cbp(s, block, motion_x, motion_y); |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
1076 |
695 | 1077 if ((cbp | motion_x | motion_y | s->dquant) == 0) { |
324 | 1078 /* skip macroblock */ |
1079 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
|
1080 if(interleaved_stats){ |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1081 s->misc_bits++; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1082 s->last_bits++; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1083 } |
324 | 1084 return; |
1085 } | |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1086 put_bits(&s->pb, 1, 0); /* mb coded */ |
1633 | 1087 |
324 | 1088 cbpc = cbp & 3; |
1637 | 1089 cbpy = cbp >> 2; |
1090 if(s->alt_inter_vlc==0 || cbpc!=3) | |
1091 cbpy ^= 0xF; | |
695 | 1092 if(s->dquant) cbpc+= 8; |
1633 | 1093 if(s->mv_type==MV_TYPE_16X16){ |
1094 put_bits(&s->pb, | |
1095 inter_MCBPC_bits[cbpc], | |
1096 inter_MCBPC_code[cbpc]); | |
1097 | |
1098 put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]); | |
1099 if(s->dquant) | |
1100 put_bits(&s->pb, 2, dquant_code[s->dquant+2]); | |
1101 | |
1102 if(interleaved_stats){ | |
1103 s->misc_bits+= get_bits_diff(s); | |
1104 } | |
1105 | |
1106 /* motion vectors: 16x16 mode */ | |
1107 h263_pred_motion(s, 0, &pred_x, &pred_y); | |
1108 | |
1109 if (!s->umvplus) { | |
1655 | 1110 h263_encode_motion(s, motion_x - pred_x, 1); |
1111 h263_encode_motion(s, motion_y - pred_y, 1); | |
1633 | 1112 } |
1113 else { | |
1114 h263p_encode_umotion(s, motion_x - pred_x); | |
1115 h263p_encode_umotion(s, motion_y - pred_y); | |
1116 if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1)) | |
1117 /* To prevent Start Code emulation */ | |
1118 put_bits(&s->pb,1,1); | |
1119 } | |
1120 }else{ | |
1121 put_bits(&s->pb, | |
1122 inter_MCBPC_bits[cbpc+16], | |
1123 inter_MCBPC_code[cbpc+16]); | |
1124 put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]); | |
1125 if(s->dquant) | |
1126 put_bits(&s->pb, 2, dquant_code[s->dquant+2]); | |
1127 | |
1128 if(interleaved_stats){ | |
1129 s->misc_bits+= get_bits_diff(s); | |
1130 } | |
1131 | |
1132 for(i=0; i<4; i++){ | |
1133 /* motion vectors: 8x8 mode*/ | |
1134 h263_pred_motion(s, i, &pred_x, &pred_y); | |
1135 | |
1668
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1666
diff
changeset
|
1136 motion_x= s->current_picture.motion_val[0][ s->block_index[i] ][0]; |
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1666
diff
changeset
|
1137 motion_y= s->current_picture.motion_val[0][ s->block_index[i] ][1]; |
1633 | 1138 if (!s->umvplus) { |
1655 | 1139 h263_encode_motion(s, motion_x - pred_x, 1); |
1140 h263_encode_motion(s, motion_y - pred_y, 1); | |
1633 | 1141 } |
1142 else { | |
1143 h263p_encode_umotion(s, motion_x - pred_x); | |
1144 h263p_encode_umotion(s, motion_y - pred_y); | |
1145 if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1)) | |
1146 /* To prevent Start Code emulation */ | |
1147 put_bits(&s->pb,1,1); | |
1148 } | |
1149 } | |
324 | 1150 } |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1151 |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1152 if(interleaved_stats){ |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1153 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
|
1154 } |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1155 } else { |
1639 | 1156 assert(s->mb_intra); |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1157 |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1158 cbp = 0; |
1666 | 1159 if (s->h263_aic) { |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1160 /* Predict DC */ |
1666 | 1161 for(i=0; i<6; i++) { |
1064 | 1162 int16_t level = block[i][0]; |
1666 | 1163 int scale; |
1164 | |
1165 if(i<4) scale= s->y_dc_scale; | |
1166 else scale= s->c_dc_scale; | |
1167 | |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1168 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
|
1169 level -= pred_dc; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1170 /* Quant */ |
1666 | 1171 if (level >= 0) |
1172 level = (level + (scale>>1))/scale; | |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1173 else |
1666 | 1174 level = (level - (scale>>1))/scale; |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1175 |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1176 /* AIC can change CBP */ |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1177 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
|
1178 s->block_last_index[i] = -1; |
1666 | 1179 |
1180 if(!s->modified_quant){ | |
1181 if (level < -127) | |
1182 level = -127; | |
1183 else if (level > 127) | |
1184 level = 127; | |
1185 } | |
1186 | |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1187 block[i][0] = level; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1188 /* Reconstruction */ |
1666 | 1189 rec_intradc[i] = scale*level + pred_dc; |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1190 /* Oddify */ |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1191 rec_intradc[i] |= 1; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1192 //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
|
1193 // rec_intradc[i]++; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1194 /* Clipping */ |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1195 if (rec_intradc[i] < 0) |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1196 rec_intradc[i] = 0; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1197 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
|
1198 rec_intradc[i] = 2047; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1199 |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1200 /* Update AC/DC tables */ |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1201 *dc_ptr[i] = rec_intradc[i]; |
1666 | 1202 if (s->block_last_index[i] >= 0) |
1203 cbp |= 1 << (5 - i); | |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1204 } |
1666 | 1205 }else{ |
1206 for(i=0; i<6; i++) { | |
1207 /* compute cbp */ | |
1208 if (s->block_last_index[i] >= 1) | |
1209 cbp |= 1 << (5 - i); | |
1210 } | |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1211 } |
0 | 1212 |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1213 cbpc = cbp & 3; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1214 if (s->pict_type == I_TYPE) { |
695 | 1215 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
|
1216 put_bits(&s->pb, |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1217 intra_MCBPC_bits[cbpc], |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1218 intra_MCBPC_code[cbpc]); |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1219 } else { |
695 | 1220 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
|
1221 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
|
1222 put_bits(&s->pb, |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1223 inter_MCBPC_bits[cbpc + 4], |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1224 inter_MCBPC_code[cbpc + 4]); |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1225 } |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1226 if (s->h263_aic) { |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1227 /* 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
|
1228 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
|
1229 } |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1230 cbpy = cbp >> 2; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1231 put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]); |
695 | 1232 if(s->dquant) |
1233 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
|
1234 |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1235 if(interleaved_stats){ |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1236 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
|
1237 } |
0 | 1238 } |
1239 | |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1240 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
|
1241 /* encode each block */ |
1354 | 1242 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
|
1243 |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1244 /* Update INTRADC for decoding */ |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1245 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
|
1246 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
|
1247 |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1248 } |
0 | 1249 } |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1250 |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1251 if(interleaved_stats){ |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1252 if (!s->mb_intra) { |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1253 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
|
1254 s->f_count++; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1255 }else{ |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1256 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
|
1257 s->i_count++; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1258 } |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1259 } |
0 | 1260 } |
815
78accc54493b
put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents:
770
diff
changeset
|
1261 #endif |
0 | 1262 |
1656 | 1263 void ff_h263_loop_filter(MpegEncContext * s){ |
1644 | 1264 int qp_c; |
1265 const int linesize = s->linesize; | |
1266 const int uvlinesize= s->uvlinesize; | |
1267 const int xy = s->mb_y * s->mb_stride + s->mb_x; | |
1268 uint8_t *dest_y = s->dest[0]; | |
1269 uint8_t *dest_cb= s->dest[1]; | |
1270 uint8_t *dest_cr= s->dest[2]; | |
1271 | |
1272 // if(s->pict_type==B_TYPE && !s->readable) return; | |
1273 | |
1274 /* | |
1275 Diag Top | |
1276 Left Center | |
1277 */ | |
1278 if(!IS_SKIP(s->current_picture.mb_type[xy])){ | |
1279 qp_c= s->qscale; | |
1280 s->dsp.h263_v_loop_filter(dest_y+8*linesize , linesize, qp_c); | |
1281 s->dsp.h263_v_loop_filter(dest_y+8*linesize+8, linesize, qp_c); | |
1282 }else | |
1283 qp_c= 0; | |
1284 | |
1285 if(s->mb_y){ | |
1286 int qp_dt, qp_t, qp_tc; | |
1287 | |
1288 if(IS_SKIP(s->current_picture.mb_type[xy-s->mb_stride])) | |
1289 qp_t=0; | |
1290 else | |
1291 qp_t= s->current_picture.qscale_table[xy-s->mb_stride]; | |
1292 | |
1293 if(qp_c) | |
1294 qp_tc= qp_c; | |
1295 else | |
1296 qp_tc= qp_t; | |
1297 | |
1298 if(qp_tc){ | |
1299 const int chroma_qp= s->chroma_qscale_table[qp_tc]; | |
1300 s->dsp.h263_v_loop_filter(dest_y , linesize, qp_tc); | |
1301 s->dsp.h263_v_loop_filter(dest_y+8, linesize, qp_tc); | |
1302 | |
1303 s->dsp.h263_v_loop_filter(dest_cb , uvlinesize, chroma_qp); | |
1304 s->dsp.h263_v_loop_filter(dest_cr , uvlinesize, chroma_qp); | |
1305 } | |
1306 | |
1307 if(qp_t) | |
1308 s->dsp.h263_h_loop_filter(dest_y-8*linesize+8 , linesize, qp_t); | |
1309 | |
1310 if(s->mb_x){ | |
1311 if(qp_t || IS_SKIP(s->current_picture.mb_type[xy-1-s->mb_stride])) | |
1312 qp_dt= qp_t; | |
1313 else | |
1314 qp_dt= s->current_picture.qscale_table[xy-1-s->mb_stride]; | |
1315 | |
1316 if(qp_dt){ | |
1317 const int chroma_qp= s->chroma_qscale_table[qp_dt]; | |
1318 s->dsp.h263_h_loop_filter(dest_y -8*linesize , linesize, qp_dt); | |
1319 s->dsp.h263_h_loop_filter(dest_cb-8*uvlinesize, uvlinesize, chroma_qp); | |
1320 s->dsp.h263_h_loop_filter(dest_cb-8*uvlinesize, uvlinesize, chroma_qp); | |
1321 } | |
1322 } | |
1323 } | |
1324 | |
1325 if(qp_c){ | |
1326 s->dsp.h263_h_loop_filter(dest_y +8, linesize, qp_c); | |
1327 if(s->mb_y + 1 == s->mb_height) | |
1328 s->dsp.h263_h_loop_filter(dest_y+8*linesize+8, linesize, qp_c); | |
1329 } | |
1330 | |
1331 if(s->mb_x){ | |
1332 int qp_lc; | |
1333 if(qp_c || IS_SKIP(s->current_picture.mb_type[xy-1])) | |
1334 qp_lc= qp_c; | |
1335 else | |
1336 qp_lc= s->current_picture.qscale_table[xy-1]; | |
1337 | |
1338 if(qp_lc){ | |
1339 s->dsp.h263_h_loop_filter(dest_y, linesize, qp_lc); | |
1340 if(s->mb_y + 1 == s->mb_height){ | |
1341 const int chroma_qp= s->chroma_qscale_table[qp_lc]; | |
1342 s->dsp.h263_h_loop_filter(dest_y +8* linesize, linesize, qp_lc); | |
1343 s->dsp.h263_h_loop_filter(dest_cb , uvlinesize, chroma_qp); | |
1344 s->dsp.h263_h_loop_filter(dest_cr , uvlinesize, chroma_qp); | |
1345 } | |
1346 } | |
1347 } | |
1348 } | |
1349 | |
1064 | 1350 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
|
1351 { |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1352 int x, y, wrap, a, c, pred_dc, scale; |
1064 | 1353 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
|
1354 |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1355 /* find prediction */ |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1356 if (n < 4) { |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1357 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
|
1358 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
|
1359 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
|
1360 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
|
1361 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
|
1362 scale = s->y_dc_scale; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1363 } else { |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1364 x = s->mb_x + 1; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1365 y = s->mb_y + 1; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1366 wrap = s->mb_width + 2; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1367 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
|
1368 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
|
1369 scale = s->c_dc_scale; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1370 } |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1371 /* B C |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1372 * A X |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1373 */ |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1374 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
|
1375 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
|
1376 |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1377 /* No prediction outside GOB boundary */ |
453 | 1378 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
|
1379 c = 1024; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1380 pred_dc = 1024; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1381 /* just DC prediction */ |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1382 if (a != 1024 && c != 1024) |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1383 pred_dc = (a + c) >> 1; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1384 else if (a != 1024) |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1385 pred_dc = a; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1386 else |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1387 pred_dc = c; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1388 |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1389 /* we assume pred is positive */ |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1390 //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
|
1391 *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
|
1392 return pred_dc; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1393 } |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1394 |
1057 | 1395 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
|
1396 { |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1397 int x, y, wrap, a, c, pred_dc, scale, i; |
1064 | 1398 int16_t *dc_val, *ac_val, *ac_val1; |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1399 |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1400 /* find prediction */ |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1401 if (n < 4) { |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1402 x = 2 * s->mb_x + 1 + (n & 1); |
1639 | 1403 y = 2 * s->mb_y + 1 + (n>> 1); |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1404 wrap = s->mb_width * 2 + 2; |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1405 dc_val = s->dc_val[0]; |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1406 ac_val = s->ac_val[0][0]; |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1407 scale = s->y_dc_scale; |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1408 } else { |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1409 x = s->mb_x + 1; |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1410 y = s->mb_y + 1; |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1411 wrap = s->mb_width + 2; |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1412 dc_val = s->dc_val[n - 4 + 1]; |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1413 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
|
1414 scale = s->c_dc_scale; |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1415 } |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1416 |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1417 ac_val += ((y) * wrap + (x)) * 16; |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1418 ac_val1 = ac_val; |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1419 |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1420 /* B C |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1421 * A X |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1422 */ |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1423 a = dc_val[(x - 1) + (y) * wrap]; |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1424 c = dc_val[(x) + (y - 1) * wrap]; |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1425 |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1426 /* No prediction outside GOB boundary */ |
1639 | 1427 if(s->first_slice_line && n!=3){ |
1428 if(n!=2) c= 1024; | |
1429 if(n!=1 && s->mb_x == s->resync_mb_x) a= 1024; | |
1430 } | |
1431 | |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1432 if (s->ac_pred) { |
1639 | 1433 pred_dc = 1024; |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1434 if (s->h263_aic_dir) { |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1435 /* left prediction */ |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1436 if (a != 1024) { |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1437 ac_val -= 16; |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1438 for(i=1;i<8;i++) { |
1092 | 1439 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
|
1440 } |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1441 pred_dc = a; |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1442 } |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1443 } else { |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1444 /* top prediction */ |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1445 if (c != 1024) { |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1446 ac_val -= 16 * wrap; |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1447 for(i=1;i<8;i++) { |
1092 | 1448 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
|
1449 } |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1450 pred_dc = c; |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1451 } |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1452 } |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1453 } else { |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1454 /* just DC prediction */ |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1455 if (a != 1024 && c != 1024) |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1456 pred_dc = (a + c) >> 1; |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1457 else if (a != 1024) |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1458 pred_dc = a; |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1459 else |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1460 pred_dc = c; |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1461 } |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1462 |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1463 /* we assume pred is positive */ |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1464 block[0]=block[0]*scale + pred_dc; |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1465 |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1466 if (block[0] < 0) |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1467 block[0] = 0; |
1639 | 1468 else |
1469 block[0] |= 1; | |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1470 |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1471 /* Update AC/DC tables */ |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1472 dc_val[(x) + (y) * wrap] = block[0]; |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1473 |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1474 /* left copy */ |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1475 for(i=1;i<8;i++) |
1092 | 1476 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
|
1477 /* top copy */ |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1478 for(i=1;i<8;i++) |
1092 | 1479 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
|
1480 } |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1481 |
1064 | 1482 int16_t *h263_pred_motion(MpegEncContext * s, int block, |
0 | 1483 int *px, int *py) |
1484 { | |
266 | 1485 int xy, wrap; |
1064 | 1486 int16_t *A, *B, *C, *mot_val; |
264
28c5c62b1c4c
support decoding (with mplayer) of 3 .mp4 files from mphq
michaelni
parents:
263
diff
changeset
|
1487 static const int off[4]= {2, 1, 1, -1}; |
0 | 1488 |
266 | 1489 wrap = s->block_wrap[0]; |
1490 xy = s->block_index[block]; | |
0 | 1491 |
1668
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1666
diff
changeset
|
1492 mot_val = s->current_picture.motion_val[0][xy]; |
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1666
diff
changeset
|
1493 |
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1666
diff
changeset
|
1494 A = s->current_picture.motion_val[0][xy - 1]; |
453 | 1495 /* special case for first (slice) line */ |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
1496 if (s->first_slice_line && block<3) { |
453 | 1497 // we cant just change some MVs to simulate that as we need them for the B frames (and ME) |
1498 // and if we ever support non rectangular objects than we need to do a few ifs here anyway :( | |
1499 if(block==0){ //most common case | |
1500 if(s->mb_x == s->resync_mb_x){ //rare | |
1501 *px= *py = 0; | |
1646
c3c166ead03a
h263 MV prediction doesnt match mpeg4, for some slices configurations (fixes RV20 MVs)
michael
parents:
1644
diff
changeset
|
1502 }else if(s->mb_x + 1 == s->resync_mb_x && s->h263_pred){ //rare |
1668
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1666
diff
changeset
|
1503 C = s->current_picture.motion_val[0][xy + off[block] - wrap]; |
453 | 1504 if(s->mb_x==0){ |
1505 *px = C[0]; | |
1506 *py = C[1]; | |
1507 }else{ | |
1508 *px = mid_pred(A[0], 0, C[0]); | |
1509 *py = mid_pred(A[1], 0, C[1]); | |
1510 } | |
1511 }else{ | |
1512 *px = A[0]; | |
1513 *py = A[1]; | |
1514 } | |
1515 }else if(block==1){ | |
1646
c3c166ead03a
h263 MV prediction doesnt match mpeg4, for some slices configurations (fixes RV20 MVs)
michael
parents:
1644
diff
changeset
|
1516 if(s->mb_x + 1 == s->resync_mb_x && s->h263_pred){ //rare |
1668
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1666
diff
changeset
|
1517 C = s->current_picture.motion_val[0][xy + off[block] - wrap]; |
453 | 1518 *px = mid_pred(A[0], 0, C[0]); |
1519 *py = mid_pred(A[1], 0, C[1]); | |
1520 }else{ | |
1521 *px = A[0]; | |
1522 *py = A[1]; | |
1523 } | |
1524 }else{ /* block==2*/ | |
1668
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1666
diff
changeset
|
1525 B = s->current_picture.motion_val[0][xy - wrap]; |
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1666
diff
changeset
|
1526 C = s->current_picture.motion_val[0][xy + off[block] - wrap]; |
453 | 1527 if(s->mb_x == s->resync_mb_x) //rare |
1528 A[0]=A[1]=0; | |
1529 | |
1530 *px = mid_pred(A[0], B[0], C[0]); | |
1531 *py = mid_pred(A[1], B[1], C[1]); | |
1532 } | |
0 | 1533 } else { |
1668
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1666
diff
changeset
|
1534 B = s->current_picture.motion_val[0][xy - wrap]; |
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1666
diff
changeset
|
1535 C = s->current_picture.motion_val[0][xy + off[block] - wrap]; |
0 | 1536 *px = mid_pred(A[0], B[0], C[0]); |
1537 *py = mid_pred(A[1], B[1], C[1]); | |
1538 } | |
1539 return mot_val; | |
1540 } | |
1541 | |
1655 | 1542 // identical to above but with s->current_picture->motion_val, the above one will be removed, and this renamed to it |
1543 int16_t *h263_pred_motion2(MpegEncContext * s, int block, int dir, | |
1544 int *px, int *py) | |
1545 { | |
1546 int xy, wrap; | |
1547 int16_t *A, *B, *C, (*mot_val)[2]; | |
1548 static const int off[4]= {2, 1, 1, -1}; | |
1549 | |
1550 wrap = s->b8_stride; | |
1551 xy = s->mb_x + s->mb_y * wrap; | |
1552 | |
1668
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1666
diff
changeset
|
1553 mot_val = s->current_picture.motion_val[0][dir] + xy; |
1655 | 1554 |
1555 A = mot_val[ - 1]; | |
1556 /* special case for first (slice) line */ | |
1557 if (s->first_slice_line && block<3) { | |
1558 // we cant just change some MVs to simulate that as we need them for the B frames (and ME) | |
1559 // and if we ever support non rectangular objects than we need to do a few ifs here anyway :( | |
1560 if(block==0){ //most common case | |
1561 if(s->mb_x == s->resync_mb_x){ //rare | |
1562 *px= *py = 0; | |
1563 }else if(s->mb_x + 1 == s->resync_mb_x && s->h263_pred){ //rare | |
1564 C = mot_val[off[block] - wrap]; | |
1565 if(s->mb_x==0){ | |
1566 *px = C[0]; | |
1567 *py = C[1]; | |
1568 }else{ | |
1569 *px = mid_pred(A[0], 0, C[0]); | |
1570 *py = mid_pred(A[1], 0, C[1]); | |
1571 } | |
1572 }else{ | |
1573 *px = A[0]; | |
1574 *py = A[1]; | |
1575 } | |
1576 }else if(block==1){ | |
1577 if(s->mb_x + 1 == s->resync_mb_x && s->h263_pred){ //rare | |
1578 C = mot_val[off[block] - wrap]; | |
1579 *px = mid_pred(A[0], 0, C[0]); | |
1580 *py = mid_pred(A[1], 0, C[1]); | |
1581 }else{ | |
1582 *px = A[0]; | |
1583 *py = A[1]; | |
1584 } | |
1585 }else{ /* block==2*/ | |
1586 B = mot_val[ - wrap]; | |
1587 C = mot_val[off[block] - wrap]; | |
1588 if(s->mb_x == s->resync_mb_x) //rare | |
1589 A[0]=A[1]=0; | |
1590 | |
1591 *px = mid_pred(A[0], B[0], C[0]); | |
1592 *py = mid_pred(A[1], B[1], C[1]); | |
1593 } | |
1594 } else { | |
1595 B = mot_val[ - wrap]; | |
1596 C = mot_val[off[block] - wrap]; | |
1597 *px = mid_pred(A[0], B[0], C[0]); | |
1598 *py = mid_pred(A[1], B[1], C[1]); | |
1599 } | |
1600 return *mot_val; | |
1601 } | |
1602 | |
815
78accc54493b
put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents:
770
diff
changeset
|
1603 #ifdef CONFIG_ENCODERS |
324 | 1604 static void h263_encode_motion(MpegEncContext * s, int val, int f_code) |
0 | 1605 { |
702 | 1606 int range, l, bit_size, sign, code, bits; |
0 | 1607 |
1608 if (val == 0) { | |
1609 /* zero vector */ | |
1610 code = 0; | |
1611 put_bits(&s->pb, mvtab[code][1], mvtab[code][0]); | |
1612 } else { | |
324 | 1613 bit_size = f_code - 1; |
0 | 1614 range = 1 << bit_size; |
1615 /* modulo encoding */ | |
1616 l = range * 32; | |
702 | 1617 #if 1 |
1618 val+= l; | |
1619 val&= 2*l-1; | |
1620 val-= l; | |
1621 sign = val>>31; | |
1622 val= (val^sign)-sign; | |
1623 sign&=1; | |
1624 #else | |
0 | 1625 if (val < -l) { |
702 | 1626 val += 2*l; |
0 | 1627 } else if (val >= l) { |
702 | 1628 val -= 2*l; |
0 | 1629 } |
702 | 1630 |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
1631 assert(val>=-l && val<l); |
0 | 1632 |
1633 if (val >= 0) { | |
1634 sign = 0; | |
1635 } else { | |
1636 val = -val; | |
1637 sign = 1; | |
1638 } | |
702 | 1639 #endif |
312 | 1640 val--; |
1641 code = (val >> bit_size) + 1; | |
1642 bits = val & (range - 1); | |
0 | 1643 |
1644 put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign); | |
1645 if (bit_size > 0) { | |
1646 put_bits(&s->pb, bit_size, bits); | |
1647 } | |
1648 } | |
718 | 1649 |
0 | 1650 } |
1651 | |
78 | 1652 /* Encode MV differences on H.263+ with Unrestricted MV mode */ |
1653 static void h263p_encode_umotion(MpegEncContext * s, int val) | |
1654 { | |
1655 short sval = 0; | |
1656 short i = 0; | |
1657 short n_bits = 0; | |
1658 short temp_val; | |
1659 int code = 0; | |
1660 int tcode; | |
1661 | |
1662 if ( val == 0) | |
1663 put_bits(&s->pb, 1, 1); | |
1664 else if (val == 1) | |
1665 put_bits(&s->pb, 3, 0); | |
1666 else if (val == -1) | |
1667 put_bits(&s->pb, 3, 2); | |
1668 else { | |
1669 | |
1670 sval = ((val < 0) ? (short)(-val):(short)val); | |
1671 temp_val = sval; | |
1672 | |
1673 while (temp_val != 0) { | |
1674 temp_val = temp_val >> 1; | |
1675 n_bits++; | |
1676 } | |
1677 | |
1678 i = n_bits - 1; | |
1679 while (i > 0) { | |
1680 tcode = (sval & (1 << (i-1))) >> (i-1); | |
1681 tcode = (tcode << 1) | 1; | |
1682 code = (code << 2) | tcode; | |
1683 i--; | |
1684 } | |
1685 code = ((code << 1) | (val < 0)) << 1; | |
1686 put_bits(&s->pb, (2*n_bits)+1, code); | |
1687 //printf("\nVal = %d\tCode = %d", sval, code); | |
1688 } | |
1689 } | |
1690 | |
277
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1691 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
|
1692 { |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1693 int f_code; |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1694 int mv; |
815
78accc54493b
put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents:
770
diff
changeset
|
1695 |
78accc54493b
put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents:
770
diff
changeset
|
1696 if(mv_penalty==NULL) |
1162 | 1697 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
|
1698 |
277
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1699 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
|
1700 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
|
1701 int len; |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1702 |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1703 if(mv==0) len= mvtab[0][1]; |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1704 else{ |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1705 int val, bit_size, range, code; |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1706 |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1707 bit_size = s->f_code - 1; |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1708 range = 1 << bit_size; |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1709 |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1710 val=mv; |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1711 if (val < 0) |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1712 val = -val; |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1713 val--; |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1714 code = (val >> bit_size) + 1; |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1715 if(code<33){ |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1716 len= mvtab[code][1] + 1 + bit_size; |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1717 }else{ |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1718 len= mvtab[32][1] + 2 + bit_size; |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1719 } |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1720 } |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1721 |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1722 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
|
1723 } |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1724 } |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1725 |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1726 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
|
1727 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
|
1728 fcode_tab[mv+MAX_MV]= f_code; |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1729 } |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1730 } |
287 | 1731 |
1732 for(mv=0; mv<MAX_MV*2+1; mv++){ | |
1733 umv_fcode_tab[mv]= 1; | |
1734 } | |
277
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1735 } |
815
78accc54493b
put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents:
770
diff
changeset
|
1736 #endif |
277
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1737 |
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
|
1738 #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
|
1739 |
468 | 1740 static void init_uni_dc_tab(void) |
293 | 1741 { |
1742 int level, uni_code, uni_len; | |
1743 | |
312 | 1744 for(level=-256; level<256; level++){ |
293 | 1745 int size, v, l; |
1746 /* find number of bits */ | |
1747 size = 0; | |
1748 v = abs(level); | |
1749 while (v) { | |
1750 v >>= 1; | |
1751 size++; | |
1752 } | |
1753 | |
1754 if (level < 0) | |
1755 l= (-level) ^ ((1 << size) - 1); | |
1756 else | |
1757 l= level; | |
1758 | |
1759 /* luminance */ | |
1760 uni_code= DCtab_lum[size][0]; | |
1761 uni_len = DCtab_lum[size][1]; | |
1762 | |
1763 if (size > 0) { | |
1764 uni_code<<=size; uni_code|=l; | |
1765 uni_len+=size; | |
1766 if (size > 8){ | |
1767 uni_code<<=1; uni_code|=1; | |
1768 uni_len++; | |
1769 } | |
1770 } | |
1013 | 1771 uni_DCtab_lum_bits[level+256]= uni_code; |
1772 uni_DCtab_lum_len [level+256]= uni_len; | |
293 | 1773 |
1774 /* chrominance */ | |
1775 uni_code= DCtab_chrom[size][0]; | |
1776 uni_len = DCtab_chrom[size][1]; | |
1777 | |
1778 if (size > 0) { | |
1779 uni_code<<=size; uni_code|=l; | |
1780 uni_len+=size; | |
1781 if (size > 8){ | |
1782 uni_code<<=1; uni_code|=1; | |
1783 uni_len++; | |
1784 } | |
1785 } | |
1013 | 1786 uni_DCtab_chrom_bits[level+256]= uni_code; |
1787 uni_DCtab_chrom_len [level+256]= uni_len; | |
293 | 1788 |
1789 } | |
1790 } | |
1791 | |
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
|
1792 #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
|
1793 |
815
78accc54493b
put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents:
770
diff
changeset
|
1794 #ifdef CONFIG_ENCODERS |
1064 | 1795 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
|
1796 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
|
1797 |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1798 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
|
1799 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
|
1800 |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1801 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
|
1802 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
|
1803 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
|
1804 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
|
1805 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
|
1806 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
|
1807 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
|
1808 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
|
1809 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
|
1810 |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1811 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
|
1812 |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1813 /* 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
|
1814 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
|
1815 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
|
1816 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
|
1817 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
|
1818 |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1819 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
|
1820 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
|
1821 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
|
1822 } |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1823 #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
|
1824 /* 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
|
1825 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
|
1826 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
|
1827 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
|
1828 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
|
1829 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
|
1830 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
|
1831 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
|
1832 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
|
1833 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
|
1834 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
|
1835 |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1836 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
|
1837 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
|
1838 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
|
1839 } |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1840 } |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1841 #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
|
1842 #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
|
1843 /* 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
|
1844 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
|
1845 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
|
1846 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
|
1847 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
|
1848 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
|
1849 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
|
1850 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
|
1851 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
|
1852 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
|
1853 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
|
1854 |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1855 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
|
1856 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
|
1857 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
|
1858 } |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1859 } |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1860 #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
|
1861 /* 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
|
1862 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
|
1863 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
|
1864 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
|
1865 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
|
1866 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
|
1867 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
|
1868 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
|
1869 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
|
1870 |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1871 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
|
1872 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
|
1873 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
|
1874 } |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1875 } |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1876 } |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1877 } |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1878 } |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1879 |
277
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1880 void h263_encode_init(MpegEncContext *s) |
0 | 1881 { |
1882 static int done = 0; | |
1883 | |
1884 if (!done) { | |
1885 done = 1; | |
293 | 1886 |
1887 init_uni_dc_tab(); | |
1888 | |
0 | 1889 init_rl(&rl_inter); |
1890 init_rl(&rl_intra); | |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1891 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
|
1892 |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1893 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
|
1894 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
|
1895 |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1896 init_mv_penalty_and_fcode(s); |
0 | 1897 } |
936 | 1898 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
|
1899 |
287 | 1900 // use fcodes >1 only for mpeg4 & h263 & h263p FIXME |
344 | 1901 switch(s->codec_id){ |
1902 case CODEC_ID_MPEG4: | |
1903 s->fcode_tab= fcode_tab; | |
1904 s->min_qcoeff= -2048; | |
1905 s->max_qcoeff= 2047; | |
945 | 1906 s->intra_ac_vlc_length = uni_mpeg4_intra_rl_len; |
1907 s->intra_ac_vlc_last_length= uni_mpeg4_intra_rl_len + 128*64; | |
1908 s->inter_ac_vlc_length = uni_mpeg4_inter_rl_len; | |
1909 s->inter_ac_vlc_last_length= uni_mpeg4_inter_rl_len + 128*64; | |
1013 | 1910 s->luma_dc_vlc_length= uni_DCtab_lum_len; |
1911 s->chroma_dc_vlc_length= uni_DCtab_chrom_len; | |
945 | 1912 s->ac_esc_length= 7+2+1+6+1+12+1; |
1424 | 1913 |
1914 if(s->flags & CODEC_FLAG_GLOBAL_HEADER){ | |
1483 | 1915 |
1424 | 1916 s->avctx->extradata= av_malloc(1024); |
1522
79dddc5cd990
removed the obsolete and unused parameters of init_put_bits
alex
parents:
1521
diff
changeset
|
1917 init_put_bits(&s->pb, s->avctx->extradata, 1024); |
1424 | 1918 |
1919 mpeg4_encode_visual_object_header(s); | |
1920 mpeg4_encode_vol_header(s, 0, 0); | |
1921 | |
1922 // ff_mpeg4_stuffing(&s->pb); ? | |
1923 flush_put_bits(&s->pb); | |
1924 s->avctx->extradata_size= (get_bit_count(&s->pb)+7)>>3; | |
1925 } | |
1926 | |
344 | 1927 break; |
1928 case CODEC_ID_H263P: | |
1666 | 1929 if(s->umvplus) |
1930 s->fcode_tab= umv_fcode_tab; | |
1931 else | |
1932 s->fcode_tab= fcode_tab; | |
1933 if(s->modified_quant){ | |
1934 s->min_qcoeff= -2047; | |
1935 s->max_qcoeff= 2047; | |
1936 }else{ | |
1937 s->min_qcoeff= -127; | |
1938 s->max_qcoeff= 127; | |
1939 } | |
344 | 1940 break; |
498 | 1941 //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
|
1942 case CODEC_ID_FLV1: |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1943 if (s->h263_flv > 1) { |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1944 s->min_qcoeff= -1023; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1945 s->max_qcoeff= 1023; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1946 } else { |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1947 s->min_qcoeff= -127; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1948 s->max_qcoeff= 127; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1949 } |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1950 s->y_dc_scale_table= |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1951 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
|
1952 break; |
344 | 1953 default: //nothing needed default table allready set in mpegvideo.c |
1089 | 1954 s->min_qcoeff= -127; |
344 | 1955 s->max_qcoeff= 127; |
498 | 1956 s->y_dc_scale_table= |
1957 s->c_dc_scale_table= ff_mpeg1_dc_scale_table; | |
344 | 1958 } |
0 | 1959 } |
1960 | |
1034 | 1961 /** |
1962 * encodes a 8x8 block. | |
1963 * @param block the 8x8 block | |
1964 * @param n block index (0-3 are luma, 4-5 are chroma) | |
1965 */ | |
0 | 1966 static void h263_encode_block(MpegEncContext * s, DCTELEM * block, int n) |
1967 { | |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1968 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
|
1969 RLTable *rl; |
0 | 1970 |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1971 rl = &rl_inter; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1972 if (s->mb_intra && !s->h263_aic) { |
231 | 1973 /* DC coef */ |
1089 | 1974 level = block[0]; |
0 | 1975 /* 255 cannot be represented, so we clamp */ |
1976 if (level > 254) { | |
1977 level = 254; | |
1978 block[0] = 254; | |
1979 } | |
231 | 1980 /* 0 cannot be represented also */ |
1089 | 1981 else if (level < 1) { |
231 | 1982 level = 1; |
1983 block[0] = 1; | |
1984 } | |
1090 | 1985 if (level == 128) //FIXME check rv10 |
1089 | 1986 put_bits(&s->pb, 8, 0xff); |
1987 else | |
1988 put_bits(&s->pb, 8, level & 0xff); | |
1989 i = 1; | |
0 | 1990 } else { |
1089 | 1991 i = 0; |
1992 if (s->h263_aic && s->mb_intra) | |
1993 rl = &rl_intra_aic; | |
1637 | 1994 |
1995 if(s->alt_inter_vlc && !s->mb_intra){ | |
1996 int aic_vlc_bits=0; | |
1997 int inter_vlc_bits=0; | |
1998 int wrong_pos=-1; | |
1999 int aic_code; | |
2000 | |
2001 last_index = s->block_last_index[n]; | |
2002 last_non_zero = i - 1; | |
2003 for (; i <= last_index; i++) { | |
2004 j = s->intra_scantable.permutated[i]; | |
2005 level = block[j]; | |
2006 if (level) { | |
2007 run = i - last_non_zero - 1; | |
2008 last = (i == last_index); | |
1663 | 2009 |
2010 if(level<0) level= -level; | |
1637 | 2011 |
2012 code = get_rl_index(rl, last, run, level); | |
2013 aic_code = get_rl_index(&rl_intra_aic, last, run, level); | |
2014 inter_vlc_bits += rl->table_vlc[code][1]+1; | |
2015 aic_vlc_bits += rl_intra_aic.table_vlc[aic_code][1]+1; | |
2016 | |
2017 if (code == rl->n) { | |
1663 | 2018 inter_vlc_bits += 1+6+8-1; |
1637 | 2019 } |
2020 if (aic_code == rl_intra_aic.n) { | |
1663 | 2021 aic_vlc_bits += 1+6+8-1; |
1637 | 2022 wrong_pos += run + 1; |
2023 }else | |
2024 wrong_pos += wrong_run[aic_code]; | |
2025 last_non_zero = i; | |
2026 } | |
2027 } | |
2028 i = 0; | |
2029 if(aic_vlc_bits < inter_vlc_bits && wrong_pos > 63) | |
2030 rl = &rl_intra_aic; | |
2031 } | |
0 | 2032 } |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
2033 |
0 | 2034 /* AC coefs */ |
2035 last_index = s->block_last_index[n]; | |
2036 last_non_zero = i - 1; | |
2037 for (; i <= last_index; i++) { | |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
702
diff
changeset
|
2038 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
|
2039 level = block[j]; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
2040 if (level) { |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
2041 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
|
2042 last = (i == last_index); |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
2043 sign = 0; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
2044 slevel = level; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
2045 if (level < 0) { |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
2046 sign = 1; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
2047 level = -level; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
2048 } |
0 | 2049 code = get_rl_index(rl, last, run, level); |
2050 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]); | |
2051 if (code == rl->n) { | |
1354 | 2052 if(s->h263_flv <= 1){ |
0 | 2053 put_bits(&s->pb, 1, last); |
2054 put_bits(&s->pb, 6, run); | |
1089 | 2055 |
2056 assert(slevel != 0); | |
2057 | |
2058 if(slevel < 128 && slevel > -128) | |
2059 put_bits(&s->pb, 8, slevel & 0xff); | |
2060 else{ | |
2061 put_bits(&s->pb, 8, 128); | |
2062 put_bits(&s->pb, 5, slevel & 0x1f); | |
2063 put_bits(&s->pb, 6, (slevel>>5)&0x3f); | |
2064 } | |
1354 | 2065 }else{ |
2066 if(slevel < 64 && slevel > -64) { | |
2067 /* 7-bit level */ | |
2068 put_bits(&s->pb, 1, 0); | |
2069 put_bits(&s->pb, 1, last); | |
2070 put_bits(&s->pb, 6, run); | |
2071 | |
2072 put_bits(&s->pb, 7, slevel & 0x7f); | |
2073 } else { | |
2074 /* 11-bit level */ | |
2075 put_bits(&s->pb, 1, 1); | |
2076 put_bits(&s->pb, 1, last); | |
2077 put_bits(&s->pb, 6, run); | |
2078 | |
2079 put_bits(&s->pb, 11, slevel & 0x7ff); | |
2080 } | |
2081 } | |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
2082 } else { |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
2083 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
|
2084 } |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
2085 last_non_zero = i; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
2086 } |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
2087 } |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
2088 } |
815
78accc54493b
put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents:
770
diff
changeset
|
2089 #endif |
0 | 2090 |
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
|
2091 #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
|
2092 |
0 | 2093 /***************************************************/ |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2094 /** |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2095 * add mpeg4 stuffing bits (01...1) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2096 */ |
453 | 2097 void ff_mpeg4_stuffing(PutBitContext * pbc) |
262 | 2098 { |
2099 int length; | |
2100 put_bits(pbc, 1, 0); | |
2101 length= (-get_bit_count(pbc))&7; | |
453 | 2102 if(length) put_bits(pbc, length, (1<<length)-1); |
262 | 2103 } |
2104 | |
327 | 2105 /* must be called before writing the header */ |
2106 void ff_set_mpeg4_time(MpegEncContext * s, int picture_number){ | |
2107 int time_div, time_mod; | |
2108 | |
1586 | 2109 if(s->current_picture_ptr->pts) |
2110 s->time= (s->current_picture_ptr->pts*s->time_increment_resolution + 500*1000)/(1000*1000); | |
654 | 2111 else |
1126
77ccf7fe3bd0
per context frame_rate_base, this should finally fix frame_rate related av sync issues
michaelni
parents:
1118
diff
changeset
|
2112 s->time= av_rescale(picture_number*(int64_t)s->avctx->frame_rate_base, s->time_increment_resolution, s->avctx->frame_rate); |
327 | 2113 time_div= s->time/s->time_increment_resolution; |
2114 time_mod= s->time%s->time_increment_resolution; | |
2115 | |
2116 if(s->pict_type==B_TYPE){ | |
664 | 2117 s->pb_time= s->pp_time - (s->last_non_b_time - s->time); |
327 | 2118 }else{ |
2119 s->last_time_base= s->time_base; | |
2120 s->time_base= time_div; | |
2121 s->pp_time= s->time - s->last_non_b_time; | |
2122 s->last_non_b_time= s->time; | |
2123 } | |
2124 } | |
2125 | |
942 | 2126 static void mpeg4_encode_gop_header(MpegEncContext * s){ |
2127 int hours, minutes, seconds; | |
2128 | |
2129 put_bits(&s->pb, 16, 0); | |
2130 put_bits(&s->pb, 16, GOP_STARTCODE); | |
2131 | |
2132 seconds= s->time/s->time_increment_resolution; | |
2133 minutes= seconds/60; seconds %= 60; | |
2134 hours= minutes/60; minutes %= 60; | |
2135 hours%=24; | |
2136 | |
2137 put_bits(&s->pb, 5, hours); | |
2138 put_bits(&s->pb, 6, minutes); | |
2139 put_bits(&s->pb, 1, 1); | |
2140 put_bits(&s->pb, 6, seconds); | |
2141 | |
2142 put_bits(&s->pb, 1, 0); //closed gov == NO | |
2143 put_bits(&s->pb, 1, 0); //broken link == NO | |
2144 | |
2145 ff_mpeg4_stuffing(&s->pb); | |
2146 } | |
2147 | |
2148 static void mpeg4_encode_visual_object_header(MpegEncContext * s){ | |
2149 int profile_and_level_indication; | |
2150 int vo_ver_id; | |
2151 | |
2152 if(s->max_b_frames || s->quarter_sample){ | |
2153 profile_and_level_indication= 0xF1; // adv simple level 1 | |
2154 vo_ver_id= 5; | |
2155 }else{ | |
2156 profile_and_level_indication= 0x01; // simple level 1 | |
2157 vo_ver_id= 1; | |
2158 } | |
2159 //FIXME levels | |
2160 | |
2161 put_bits(&s->pb, 16, 0); | |
2162 put_bits(&s->pb, 16, VOS_STARTCODE); | |
1350
e7c8051e1849
the reference sw doesnt like some legal headers ...
michaelni
parents:
1346
diff
changeset
|
2163 |
942 | 2164 put_bits(&s->pb, 8, profile_and_level_indication); |
1350
e7c8051e1849
the reference sw doesnt like some legal headers ...
michaelni
parents:
1346
diff
changeset
|
2165 |
942 | 2166 put_bits(&s->pb, 16, 0); |
2167 put_bits(&s->pb, 16, VISUAL_OBJ_STARTCODE); | |
2168 | |
2169 put_bits(&s->pb, 1, 1); | |
2170 put_bits(&s->pb, 4, vo_ver_id); | |
2171 put_bits(&s->pb, 3, 1); //priority | |
2172 | |
2173 put_bits(&s->pb, 4, 1); //visual obj type== video obj | |
2174 | |
2175 put_bits(&s->pb, 1, 0); //video signal type == no clue //FIXME | |
2176 | |
2177 ff_mpeg4_stuffing(&s->pb); | |
2178 } | |
2179 | |
2180 static void mpeg4_encode_vol_header(MpegEncContext * s, int vo_number, int vol_number) | |
0 | 2181 { |
942 | 2182 int vo_ver_id; |
336 | 2183 |
942 | 2184 if(s->max_b_frames || s->quarter_sample){ |
2185 vo_ver_id= 5; | |
923 | 2186 s->vo_type= ADV_SIMPLE_VO_TYPE; |
2187 }else{ | |
942 | 2188 vo_ver_id= 1; |
923 | 2189 s->vo_type= SIMPLE_VO_TYPE; |
2190 } | |
336 | 2191 |
263 | 2192 put_bits(&s->pb, 16, 0); |
942 | 2193 put_bits(&s->pb, 16, 0x100 + vo_number); /* video obj */ |
263 | 2194 put_bits(&s->pb, 16, 0); |
942 | 2195 put_bits(&s->pb, 16, 0x120 + vol_number); /* video obj layer */ |
263 | 2196 |
2197 put_bits(&s->pb, 1, 0); /* random access vol */ | |
336 | 2198 put_bits(&s->pb, 8, s->vo_type); /* video obj type indication */ |
263 | 2199 put_bits(&s->pb, 1, 1); /* is obj layer id= yes */ |
2200 put_bits(&s->pb, 4, vo_ver_id); /* is obj layer ver id */ | |
2201 put_bits(&s->pb, 3, 1); /* is obj layer priority */ | |
880 | 2202 |
1548 | 2203 aspect_to_info(s, s->avctx->sample_aspect_ratio); |
880 | 2204 |
2205 put_bits(&s->pb, 4, s->aspect_ratio_info);/* aspect ratio info */ | |
1548 | 2206 if (s->aspect_ratio_info == FF_ASPECT_EXTENDED){ |
2207 put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.num); | |
2208 put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.den); | |
669
b4bddbde44f3
aspect (ext. par too) support for h263 and mpeg4 (inc. build becouse of new vars)
al3x
parents:
667
diff
changeset
|
2209 } |
336 | 2210 |
2211 if(s->low_delay){ | |
2212 put_bits(&s->pb, 1, 1); /* vol control parameters= yes */ | |
341 | 2213 put_bits(&s->pb, 2, 1); /* chroma format YUV 420/YV12 */ |
336 | 2214 put_bits(&s->pb, 1, s->low_delay); |
2215 put_bits(&s->pb, 1, 0); /* vbv parameters= no */ | |
2216 }else{ | |
2217 put_bits(&s->pb, 1, 0); /* vol control parameters= no */ | |
2218 } | |
2219 | |
263 | 2220 put_bits(&s->pb, 2, RECT_SHAPE); /* vol shape= rectangle */ |
2221 put_bits(&s->pb, 1, 1); /* marker bit */ | |
324 | 2222 |
2223 put_bits(&s->pb, 16, s->time_increment_resolution); | |
263 | 2224 if (s->time_increment_bits < 1) |
2225 s->time_increment_bits = 1; | |
2226 put_bits(&s->pb, 1, 1); /* marker bit */ | |
2227 put_bits(&s->pb, 1, 0); /* fixed vop rate=no */ | |
2228 put_bits(&s->pb, 1, 1); /* marker bit */ | |
2229 put_bits(&s->pb, 13, s->width); /* vol width */ | |
2230 put_bits(&s->pb, 1, 1); /* marker bit */ | |
2231 put_bits(&s->pb, 13, s->height); /* vol height */ | |
2232 put_bits(&s->pb, 1, 1); /* marker bit */ | |
697 | 2233 put_bits(&s->pb, 1, s->progressive_sequence ? 0 : 1); |
263 | 2234 put_bits(&s->pb, 1, 1); /* obmc disable */ |
2235 if (vo_ver_id == 1) { | |
2236 put_bits(&s->pb, 1, s->vol_sprite_usage=0); /* sprite enable */ | |
942 | 2237 }else{ |
263 | 2238 put_bits(&s->pb, 2, s->vol_sprite_usage=0); /* sprite enable */ |
2239 } | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2240 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2241 s->quant_precision=5; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2242 put_bits(&s->pb, 1, 0); /* not 8 bit == false */ |
599 | 2243 put_bits(&s->pb, 1, s->mpeg_quant); /* quant type= (0=h263 style)*/ |
1411 | 2244 |
2245 if(s->mpeg_quant){ | |
2246 ff_write_quant_matrix(&s->pb, s->avctx->intra_matrix); | |
2247 ff_write_quant_matrix(&s->pb, s->avctx->inter_matrix); | |
2248 } | |
599 | 2249 |
263 | 2250 if (vo_ver_id != 1) |
936 | 2251 put_bits(&s->pb, 1, s->quarter_sample); |
263 | 2252 put_bits(&s->pb, 1, 1); /* complexity estimation disable */ |
453 | 2253 s->resync_marker= s->rtp_mode; |
2254 put_bits(&s->pb, 1, s->resync_marker ? 0 : 1);/* resync marker disable */ | |
2255 put_bits(&s->pb, 1, s->data_partitioning ? 1 : 0); | |
2256 if(s->data_partitioning){ | |
2257 put_bits(&s->pb, 1, 0); /* no rvlc */ | |
2258 } | |
2259 | |
263 | 2260 if (vo_ver_id != 1){ |
2261 put_bits(&s->pb, 1, 0); /* newpred */ | |
2262 put_bits(&s->pb, 1, 0); /* reduced res vop */ | |
2263 } | |
2264 put_bits(&s->pb, 1, 0); /* scalability */ | |
676 | 2265 |
453 | 2266 ff_mpeg4_stuffing(&s->pb); |
676 | 2267 |
2268 /* user data */ | |
1092 | 2269 if(!(s->flags & CODEC_FLAG_BITEXACT)){ |
676 | 2270 put_bits(&s->pb, 16, 0); |
2271 put_bits(&s->pb, 16, 0x1B2); /* user_data */ | |
1118 | 2272 put_string(&s->pb, LIBAVCODEC_IDENT); |
676 | 2273 ff_mpeg4_stuffing(&s->pb); |
2274 } | |
263 | 2275 } |
2276 | |
2277 /* write mpeg4 VOP header */ | |
2278 void mpeg4_encode_picture_header(MpegEncContext * s, int picture_number) | |
2279 { | |
324 | 2280 int time_incr; |
2281 int time_div, time_mod; | |
2282 | |
453 | 2283 if(s->pict_type==I_TYPE){ |
953 | 2284 if(!(s->flags&CODEC_FLAG_GLOBAL_HEADER)){ |
1350
e7c8051e1849
the reference sw doesnt like some legal headers ...
michaelni
parents:
1346
diff
changeset
|
2285 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
|
2286 mpeg4_encode_visual_object_header(s); |
e7c8051e1849
the reference sw doesnt like some legal headers ...
michaelni
parents:
1346
diff
changeset
|
2287 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
|
2288 mpeg4_encode_vol_header(s, 0, 0); |
942 | 2289 } |
2290 mpeg4_encode_gop_header(s); | |
453 | 2291 } |
324 | 2292 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2293 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
|
2294 |
324 | 2295 //printf("num:%d rate:%d base:%d\n", s->picture_number, s->frame_rate, FRAME_RATE_BASE); |
2296 | |
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
|
2297 put_bits(&s->pb, 16, 0); /* vop header */ |
942 | 2298 put_bits(&s->pb, 16, VOP_STARTCODE); /* vop header */ |
0 | 2299 put_bits(&s->pb, 2, s->pict_type - 1); /* pict type: I = 0 , P = 1 */ |
324 | 2300 |
327 | 2301 time_div= s->time/s->time_increment_resolution; |
2302 time_mod= s->time%s->time_increment_resolution; | |
324 | 2303 time_incr= time_div - s->last_time_base; |
2304 while(time_incr--) | |
2305 put_bits(&s->pb, 1, 1); | |
2306 | |
0 | 2307 put_bits(&s->pb, 1, 0); |
2308 | |
2309 put_bits(&s->pb, 1, 1); /* marker */ | |
324 | 2310 put_bits(&s->pb, s->time_increment_bits, time_mod); /* time increment */ |
0 | 2311 put_bits(&s->pb, 1, 1); /* marker */ |
2312 put_bits(&s->pb, 1, 1); /* vop coded */ | |
263 | 2313 if ( s->pict_type == P_TYPE |
2314 || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE)) { | |
0 | 2315 put_bits(&s->pb, 1, s->no_rounding); /* rounding type */ |
2316 } | |
2317 put_bits(&s->pb, 3, 0); /* intra dc VLC threshold */ | |
697 | 2318 if(!s->progressive_sequence){ |
1659 | 2319 put_bits(&s->pb, 1, s->current_picture_ptr->top_field_first); |
697 | 2320 put_bits(&s->pb, 1, s->alternate_scan); |
2321 } | |
263 | 2322 //FIXME sprite stuff |
0 | 2323 |
2324 put_bits(&s->pb, 5, s->qscale); | |
2325 | |
2326 if (s->pict_type != I_TYPE) | |
2327 put_bits(&s->pb, 3, s->f_code); /* fcode_for */ | |
263 | 2328 if (s->pict_type == B_TYPE) |
2329 put_bits(&s->pb, 3, s->b_code); /* fcode_back */ | |
0 | 2330 // printf("****frame %d\n", picture_number); |
498 | 2331 |
2332 s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table; //FIXME add short header support | |
2333 s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table; | |
0 | 2334 } |
2335 | |
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
|
2336 #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
|
2337 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2338 /** |
1652 | 2339 * set qscale and update qscale dependant variables. |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2340 */ |
1652 | 2341 void ff_set_qscale(MpegEncContext * s, int qscale) |
0 | 2342 { |
1652 | 2343 if (qscale < 1) |
2344 qscale = 1; | |
2345 else if (qscale > 31) | |
2346 qscale = 31; | |
1644 | 2347 |
1652 | 2348 s->qscale = qscale; |
2349 s->chroma_qscale= s->chroma_qscale_table[qscale]; | |
2350 | |
2351 s->y_dc_scale= s->y_dc_scale_table[ qscale ]; | |
1644 | 2352 s->c_dc_scale= s->c_dc_scale_table[ s->chroma_qscale ]; |
0 | 2353 } |
2354 | |
1034 | 2355 /** |
2356 * predicts the dc. | |
2357 * @param n block index (0-3 are luma, 4-5 are chroma) | |
2358 * @param dc_val_ptr a pointer to the dc_val entry for the current MB will be stored here | |
2359 * @param dir_ptr pointer to an integer where the prediction direction will be stored | |
2360 * @return the quantized predicted dc | |
2361 */ | |
1064 | 2362 static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, uint16_t **dc_val_ptr, int *dir_ptr) |
0 | 2363 { |
266 | 2364 int a, b, c, wrap, pred, scale; |
1064 | 2365 uint16_t *dc_val; |
0 | 2366 |
2367 /* find prediction */ | |
2368 if (n < 4) { | |
2369 scale = s->y_dc_scale; | |
2370 } else { | |
2371 scale = s->c_dc_scale; | |
2372 } | |
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
|
2373 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
|
2374 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
|
2375 |
266 | 2376 wrap= s->block_wrap[n]; |
2377 dc_val = s->dc_val[0] + s->block_index[n]; | |
0 | 2378 |
2379 /* B C | |
2380 * A X | |
2381 */ | |
266 | 2382 a = dc_val[ - 1]; |
2383 b = dc_val[ - 1 - wrap]; | |
2384 c = dc_val[ - wrap]; | |
0 | 2385 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2386 /* 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
|
2387 if(s->first_slice_line && n!=3){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2388 if(n!=2) b=c= 1024; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2389 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
|
2390 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2391 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
|
2392 if(n==0 || n==4 || n==5) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2393 b=1024; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2394 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2395 |
0 | 2396 if (abs(a - b) < abs(b - c)) { |
2397 pred = c; | |
2398 *dir_ptr = 1; /* top */ | |
2399 } else { | |
2400 pred = a; | |
2401 *dir_ptr = 0; /* left */ | |
2402 } | |
2403 /* 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
|
2404 pred = FASTDIV((pred + (scale >> 1)), scale); |
0 | 2405 |
2406 /* prepare address for prediction update */ | |
266 | 2407 *dc_val_ptr = &dc_val[0]; |
0 | 2408 |
2409 return pred; | |
2410 } | |
2411 | |
1034 | 2412 /** |
2413 * predicts the ac. | |
2414 * @param n block index (0-3 are luma, 4-5 are chroma) | |
2415 * @param dir the ac prediction direction | |
2416 */ | |
1008 | 2417 void mpeg4_pred_ac(MpegEncContext * s, DCTELEM *block, int n, |
0 | 2418 int dir) |
2419 { | |
266 | 2420 int i; |
1064 | 2421 int16_t *ac_val, *ac_val1; |
903 | 2422 int8_t * const qscale_table= s->current_picture.qscale_table; |
0 | 2423 |
2424 /* find prediction */ | |
266 | 2425 ac_val = s->ac_val[0][0] + s->block_index[n] * 16; |
0 | 2426 ac_val1 = ac_val; |
2427 if (s->ac_pred) { | |
2428 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
|
2429 const int xy= s->mb_x-1 + s->mb_y*s->mb_stride; |
0 | 2430 /* left prediction */ |
2431 ac_val -= 16; | |
575 | 2432 |
903 | 2433 if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){ |
575 | 2434 /* same qscale */ |
2435 for(i=1;i<8;i++) { | |
1092 | 2436 block[s->dsp.idct_permutation[i<<3]] += ac_val[i]; |
575 | 2437 } |
2438 }else{ | |
2439 /* different qscale, we must rescale */ | |
2440 for(i=1;i<8;i++) { | |
1092 | 2441 block[s->dsp.idct_permutation[i<<3]] += ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale); |
575 | 2442 } |
0 | 2443 } |
2444 } 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
|
2445 const int xy= s->mb_x + s->mb_y*s->mb_stride - s->mb_stride; |
0 | 2446 /* top prediction */ |
266 | 2447 ac_val -= 16 * s->block_wrap[n]; |
575 | 2448 |
903 | 2449 if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){ |
575 | 2450 /* same qscale */ |
2451 for(i=1;i<8;i++) { | |
1092 | 2452 block[s->dsp.idct_permutation[i]] += ac_val[i + 8]; |
575 | 2453 } |
2454 }else{ | |
2455 /* different qscale, we must rescale */ | |
2456 for(i=1;i<8;i++) { | |
1092 | 2457 block[s->dsp.idct_permutation[i]] += ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale); |
575 | 2458 } |
0 | 2459 } |
2460 } | |
2461 } | |
2462 /* left copy */ | |
2463 for(i=1;i<8;i++) | |
1092 | 2464 ac_val1[i ] = block[s->dsp.idct_permutation[i<<3]]; |
591 | 2465 |
0 | 2466 /* top copy */ |
2467 for(i=1;i<8;i++) | |
1092 | 2468 ac_val1[8 + i] = block[s->dsp.idct_permutation[i ]]; |
591 | 2469 |
0 | 2470 } |
2471 | |
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
|
2472 #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
|
2473 |
1034 | 2474 /** |
2475 * encodes the dc value. | |
2476 * @param n block index (0-3 are luma, 4-5 are chroma) | |
2477 */ | |
453 | 2478 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
|
2479 { |
293 | 2480 #if 1 |
453 | 2481 // if(level<-255 || level>255) printf("dc overflow\n"); |
293 | 2482 level+=256; |
2483 if (n < 4) { | |
2484 /* luminance */ | |
1013 | 2485 put_bits(s, uni_DCtab_lum_len[level], uni_DCtab_lum_bits[level]); |
293 | 2486 } else { |
2487 /* chrominance */ | |
1013 | 2488 put_bits(s, uni_DCtab_chrom_len[level], uni_DCtab_chrom_bits[level]); |
293 | 2489 } |
2490 #else | |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
2491 int size, v; |
0 | 2492 /* find number of bits */ |
2493 size = 0; | |
2494 v = abs(level); | |
2495 while (v) { | |
2496 v >>= 1; | |
2497 size++; | |
2498 } | |
2499 | |
2500 if (n < 4) { | |
2501 /* luminance */ | |
2502 put_bits(&s->pb, DCtab_lum[size][1], DCtab_lum[size][0]); | |
2503 } else { | |
2504 /* chrominance */ | |
2505 put_bits(&s->pb, DCtab_chrom[size][1], DCtab_chrom[size][0]); | |
2506 } | |
2507 | |
2508 /* encode remaining bits */ | |
2509 if (size > 0) { | |
2510 if (level < 0) | |
2511 level = (-level) ^ ((1 << size) - 1); | |
2512 put_bits(&s->pb, size, level); | |
2513 if (size > 8) | |
2514 put_bits(&s->pb, 1, 1); | |
2515 } | |
293 | 2516 #endif |
0 | 2517 } |
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
|
2518 |
1034 | 2519 /** |
2520 * encodes a 8x8 block | |
2521 * @param n block index (0-3 are luma, 4-5 are chroma) | |
2522 */ | |
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
|
2523 static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n, int intra_dc, |
1064 | 2524 uint8_t *scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb) |
0 | 2525 { |
751 | 2526 int i, last_non_zero; |
2527 #if 0 //variables for the outcommented version | |
2528 int code, sign, last; | |
2529 #endif | |
0 | 2530 const RLTable *rl; |
1064 | 2531 uint32_t *bits_tab; |
2532 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
|
2533 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
|
2534 |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
2535 if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away |
0 | 2536 /* mpeg4 based DC predictor */ |
453 | 2537 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
|
2538 if(last_index<1) return; |
0 | 2539 i = 1; |
2540 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
|
2541 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
|
2542 len_tab = uni_mpeg4_intra_rl_len; |
0 | 2543 } 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
|
2544 if(last_index<0) return; |
0 | 2545 i = 0; |
2546 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
|
2547 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
|
2548 len_tab = uni_mpeg4_inter_rl_len; |
0 | 2549 } |
2550 | |
2551 /* AC coefs */ | |
2552 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
|
2553 #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
|
2554 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
|
2555 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
|
2556 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
|
2557 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
|
2558 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
|
2559 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
|
2560 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
|
2561 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
|
2562 }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
|
2563 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
|
2564 } |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
2565 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
|
2566 } |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
2567 } |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
2568 /*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
|
2569 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
|
2570 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
|
2571 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
|
2572 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
|
2573 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
|
2574 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
|
2575 }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
|
2576 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
|
2577 } |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
2578 } |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
2579 #else |
0 | 2580 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
|
2581 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
|
2582 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
|
2583 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
|
2584 int run = i - last_non_zero - 1; |
0 | 2585 last = (i == last_index); |
2586 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
|
2587 level = slevel; |
0 | 2588 if (level < 0) { |
2589 sign = 1; | |
2590 level = -level; | |
2591 } | |
2592 code = get_rl_index(rl, last, run, level); | |
453 | 2593 put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]); |
0 | 2594 if (code == rl->n) { |
2595 int level1, run1; | |
2596 level1 = level - rl->max_level[last][run]; | |
2597 if (level1 < 1) | |
2598 goto esc2; | |
2599 code = get_rl_index(rl, last, run, level1); | |
2600 if (code == rl->n) { | |
2601 esc2: | |
453 | 2602 put_bits(ac_pb, 1, 1); |
0 | 2603 if (level > MAX_LEVEL) |
2604 goto esc3; | |
2605 run1 = run - rl->max_run[last][level] - 1; | |
2606 if (run1 < 0) | |
2607 goto esc3; | |
2608 code = get_rl_index(rl, last, run1, level); | |
2609 if (code == rl->n) { | |
2610 esc3: | |
2611 /* third escape */ | |
453 | 2612 put_bits(ac_pb, 1, 1); |
2613 put_bits(ac_pb, 1, last); | |
2614 put_bits(ac_pb, 6, run); | |
2615 put_bits(ac_pb, 1, 1); | |
2616 put_bits(ac_pb, 12, slevel & 0xfff); | |
2617 put_bits(ac_pb, 1, 1); | |
0 | 2618 } else { |
2619 /* second escape */ | |
453 | 2620 put_bits(ac_pb, 1, 0); |
2621 put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]); | |
2622 put_bits(ac_pb, 1, sign); | |
0 | 2623 } |
2624 } else { | |
2625 /* first escape */ | |
453 | 2626 put_bits(ac_pb, 1, 0); |
2627 put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]); | |
2628 put_bits(ac_pb, 1, sign); | |
0 | 2629 } |
2630 } else { | |
453 | 2631 put_bits(ac_pb, 1, sign); |
0 | 2632 } |
2633 last_non_zero = i; | |
2634 } | |
2635 } | |
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
|
2636 #endif |
0 | 2637 } |
936 | 2638 |
2639 static inline int mpeg4_get_block_length(MpegEncContext * s, DCTELEM * block, int n, int intra_dc, | |
1064 | 2640 uint8_t *scan_table) |
936 | 2641 { |
2642 int i, last_non_zero; | |
2643 const RLTable *rl; | |
1064 | 2644 uint8_t *len_tab; |
936 | 2645 const int last_index = s->block_last_index[n]; |
2646 int len=0; | |
2647 | |
2648 if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away | |
2649 /* mpeg4 based DC predictor */ | |
2650 //mpeg4_encode_dc(dc_pb, intra_dc, n); //FIXME | |
2651 if(last_index<1) return len; | |
2652 i = 1; | |
2653 rl = &rl_intra; | |
2654 len_tab = uni_mpeg4_intra_rl_len; | |
2655 } else { | |
2656 if(last_index<0) return 0; | |
2657 i = 0; | |
2658 rl = &rl_inter; | |
2659 len_tab = uni_mpeg4_inter_rl_len; | |
2660 } | |
2661 | |
2662 /* AC coefs */ | |
2663 last_non_zero = i - 1; | |
2664 for (; i < last_index; i++) { | |
2665 int level = block[ scan_table[i] ]; | |
2666 if (level) { | |
2667 int run = i - last_non_zero - 1; | |
2668 level+=64; | |
2669 if((level&(~127)) == 0){ | |
2670 const int index= UNI_MPEG4_ENC_INDEX(0, run, level); | |
2671 len += len_tab[index]; | |
2672 }else{ //ESC3 | |
2673 len += 7+2+1+6+1+12+1; | |
2674 } | |
2675 last_non_zero = i; | |
2676 } | |
2677 } | |
2678 /*if(i<=last_index)*/{ | |
2679 int level = block[ scan_table[i] ]; | |
2680 int run = i - last_non_zero - 1; | |
2681 level+=64; | |
2682 if((level&(~127)) == 0){ | |
2683 const int index= UNI_MPEG4_ENC_INDEX(1, run, level); | |
2684 len += len_tab[index]; | |
2685 }else{ //ESC3 | |
2686 len += 7+2+1+6+1+12+1; | |
2687 } | |
2688 } | |
2689 | |
2690 return len; | |
2691 } | |
2692 | |
815
78accc54493b
put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents:
770
diff
changeset
|
2693 #endif |
0 | 2694 |
2695 | |
2696 /***********************************************/ | |
2697 /* decoding */ | |
2698 | |
2699 static VLC intra_MCBPC_vlc; | |
2700 static VLC inter_MCBPC_vlc; | |
2701 static VLC cbpy_vlc; | |
2702 static VLC mv_vlc; | |
2703 static VLC dc_lum, dc_chrom; | |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
2704 static VLC sprite_trajectory; |
262 | 2705 static VLC mb_type_b_vlc; |
1655 | 2706 static VLC h263_mbtype_b_vlc; |
2707 static VLC cbpc_b_vlc; | |
0 | 2708 |
2709 void init_vlc_rl(RLTable *rl) | |
2710 { | |
542 | 2711 int i, q; |
2712 | |
0 | 2713 init_vlc(&rl->vlc, 9, rl->n + 1, |
2714 &rl->table_vlc[0][1], 4, 2, | |
2715 &rl->table_vlc[0][0], 4, 2); | |
542 | 2716 |
2717 | |
2718 for(q=0; q<32; q++){ | |
2719 int qmul= q*2; | |
2720 int qadd= (q-1)|1; | |
2721 | |
2722 if(q==0){ | |
2723 qmul=1; | |
2724 qadd=0; | |
2725 } | |
2726 | |
2727 rl->rl_vlc[q]= av_malloc(rl->vlc.table_size*sizeof(RL_VLC_ELEM)); | |
2728 for(i=0; i<rl->vlc.table_size; i++){ | |
2729 int code= rl->vlc.table[i][0]; | |
2730 int len = rl->vlc.table[i][1]; | |
2731 int level, run; | |
2732 | |
2733 if(len==0){ // illegal code | |
563 | 2734 run= 66; |
542 | 2735 level= MAX_LEVEL; |
2736 }else if(len<0){ //more bits needed | |
2737 run= 0; | |
2738 level= code; | |
2739 }else{ | |
2740 if(code==rl->n){ //esc | |
563 | 2741 run= 66; |
542 | 2742 level= 0; |
2743 }else{ | |
2744 run= rl->table_run [code] + 1; | |
2745 level= rl->table_level[code] * qmul + qadd; | |
2746 if(code >= rl->last) run+=192; | |
2747 } | |
2748 } | |
2749 rl->rl_vlc[q][i].len= len; | |
2750 rl->rl_vlc[q][i].level= level; | |
2751 rl->rl_vlc[q][i].run= run; | |
2752 } | |
2753 } | |
0 | 2754 } |
2755 | |
2756 /* init vlcs */ | |
2757 | |
2758 /* XXX: find a better solution to handle static init */ | |
2759 void h263_decode_init_vlc(MpegEncContext *s) | |
2760 { | |
2761 static int done = 0; | |
2762 | |
2763 if (!done) { | |
2764 done = 1; | |
2765 | |
1482 | 2766 init_vlc(&intra_MCBPC_vlc, INTRA_MCBPC_VLC_BITS, 9, |
0 | 2767 intra_MCBPC_bits, 1, 1, |
2768 intra_MCBPC_code, 1, 1); | |
1482 | 2769 init_vlc(&inter_MCBPC_vlc, INTER_MCBPC_VLC_BITS, 28, |
0 | 2770 inter_MCBPC_bits, 1, 1, |
2771 inter_MCBPC_code, 1, 1); | |
544 | 2772 init_vlc(&cbpy_vlc, CBPY_VLC_BITS, 16, |
0 | 2773 &cbpy_tab[0][1], 2, 1, |
2774 &cbpy_tab[0][0], 2, 1); | |
544 | 2775 init_vlc(&mv_vlc, MV_VLC_BITS, 33, |
0 | 2776 &mvtab[0][1], 2, 1, |
2777 &mvtab[0][0], 2, 1); | |
2778 init_rl(&rl_inter); | |
2779 init_rl(&rl_intra); | |
1132 | 2780 init_rl(&rvlc_rl_inter); |
2781 init_rl(&rvlc_rl_intra); | |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
2782 init_rl(&rl_intra_aic); |
0 | 2783 init_vlc_rl(&rl_inter); |
2784 init_vlc_rl(&rl_intra); | |
1132 | 2785 init_vlc_rl(&rvlc_rl_inter); |
2786 init_vlc_rl(&rvlc_rl_intra); | |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
2787 init_vlc_rl(&rl_intra_aic); |
549 | 2788 init_vlc(&dc_lum, DC_VLC_BITS, 10 /* 13 */, |
0 | 2789 &DCtab_lum[0][1], 2, 1, |
2790 &DCtab_lum[0][0], 2, 1); | |
549 | 2791 init_vlc(&dc_chrom, DC_VLC_BITS, 10 /* 13 */, |
0 | 2792 &DCtab_chrom[0][1], 2, 1, |
2793 &DCtab_chrom[0][0], 2, 1); | |
544 | 2794 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
|
2795 &sprite_trajectory_tab[0][1], 4, 2, |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
2796 &sprite_trajectory_tab[0][0], 4, 2); |
544 | 2797 init_vlc(&mb_type_b_vlc, MB_TYPE_B_VLC_BITS, 4, |
262 | 2798 &mb_type_b_tab[0][1], 2, 1, |
2799 &mb_type_b_tab[0][0], 2, 1); | |
1655 | 2800 init_vlc(&h263_mbtype_b_vlc, H263_MBTYPE_B_VLC_BITS, 15, |
2801 &h263_mbtype_b_tab[0][1], 2, 1, | |
2802 &h263_mbtype_b_tab[0][0], 2, 1); | |
2803 init_vlc(&cbpc_b_vlc, CBPC_B_VLC_BITS, 4, | |
2804 &cbpc_b_tab[0][1], 2, 1, | |
2805 &cbpc_b_tab[0][0], 2, 1); | |
0 | 2806 } |
2807 } | |
2808 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2809 /** |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2810 * 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
|
2811 */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2812 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
|
2813 if (s->height <= 400) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2814 return 1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2815 else if (s->height <= 800) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2816 return 2; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2817 else |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2818 return 4; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2819 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2820 |
1661 | 2821 int ff_h263_decode_mba(MpegEncContext *s) |
2822 { | |
2823 int i, mb_pos; | |
2824 | |
2825 for(i=0; i<6; i++){ | |
1670 | 2826 if(s->mb_num-1 <= ff_mba_max[i]) break; |
1661 | 2827 } |
2828 mb_pos= get_bits(&s->gb, ff_mba_length[i]); | |
2829 s->mb_x= mb_pos % s->mb_width; | |
2830 s->mb_y= mb_pos / s->mb_width; | |
2831 | |
2832 return mb_pos; | |
2833 } | |
2834 | |
2835 void ff_h263_encode_mba(MpegEncContext *s) | |
2836 { | |
2837 int i, mb_pos; | |
2838 | |
2839 for(i=0; i<6; i++){ | |
1670 | 2840 if(s->mb_num-1 <= ff_mba_max[i]) break; |
1661 | 2841 } |
2842 mb_pos= s->mb_x + s->mb_width*s->mb_y; | |
2843 put_bits(&s->pb, ff_mba_length[i], mb_pos); | |
2844 } | |
2845 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2846 /** |
1661 | 2847 * decodes the group of blocks header or slice header. |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2848 * @return <0 if an error occured |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2849 */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2850 static int h263_decode_gob_header(MpegEncContext *s) |
162 | 2851 { |
1661 | 2852 unsigned int val, gfid, gob_number; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2853 int left; |
162 | 2854 |
2855 /* Check for GOB Start Code */ | |
2856 val = show_bits(&s->gb, 16); | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2857 if(val) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2858 return -1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2859 |
162 | 2860 /* 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
|
2861 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
|
2862 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
|
2863 //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
|
2864 for(;left>13; left--){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2865 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
|
2866 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2867 if(left<=13) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2868 return -1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2869 |
1661 | 2870 if(s->h263_slice_structured){ |
2871 if(get_bits1(&s->gb)==0) | |
2872 return -1; | |
2873 | |
2874 ff_h263_decode_mba(s); | |
2875 | |
2876 if(s->mb_num > 1583) | |
2877 if(get_bits1(&s->gb)==0) | |
2878 return -1; | |
2879 | |
2880 s->qscale = get_bits(&s->gb, 5); /* SQUANT */ | |
2881 if(get_bits1(&s->gb)==0) | |
2882 return -1; | |
2883 gfid = get_bits(&s->gb, 2); /* GFID */ | |
2884 }else{ | |
2885 gob_number = get_bits(&s->gb, 5); /* GN */ | |
2886 s->mb_x= 0; | |
2887 s->mb_y= s->gob_index* gob_number; | |
2888 gfid = get_bits(&s->gb, 2); /* GFID */ | |
2889 s->qscale = get_bits(&s->gb, 5); /* GQUANT */ | |
2890 } | |
2891 | |
2892 if(s->mb_y >= s->mb_height) | |
2893 return -1; | |
2894 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2895 if(s->qscale==0) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2896 return -1; |
1644 | 2897 |
162 | 2898 return 0; |
2899 } | |
2900 | |
290 | 2901 static inline void memsetw(short *tab, int val, int n) |
2902 { | |
2903 int i; | |
2904 for(i=0;i<n;i++) | |
2905 tab[i] = val; | |
2906 } | |
2907 | |
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
|
2908 #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
|
2909 |
453 | 2910 void ff_mpeg4_init_partitions(MpegEncContext *s) |
2911 { | |
1522
79dddc5cd990
removed the obsolete and unused parameters of init_put_bits
alex
parents:
1521
diff
changeset
|
2912 init_put_bits(&s->tex_pb, s->tex_pb_buffer, PB_BUFFER_SIZE); |
79dddc5cd990
removed the obsolete and unused parameters of init_put_bits
alex
parents:
1521
diff
changeset
|
2913 init_put_bits(&s->pb2 , s->pb2_buffer , PB_BUFFER_SIZE); |
453 | 2914 } |
2915 | |
2916 void ff_mpeg4_merge_partitions(MpegEncContext *s) | |
290 | 2917 { |
453 | 2918 const int pb2_len = get_bit_count(&s->pb2 ); |
2919 const int tex_pb_len= get_bit_count(&s->tex_pb); | |
2920 const int bits= get_bit_count(&s->pb); | |
2921 | |
2922 if(s->pict_type==I_TYPE){ | |
2923 put_bits(&s->pb, 19, DC_MARKER); | |
2924 s->misc_bits+=19 + pb2_len + bits - s->last_bits; | |
2925 s->i_tex_bits+= tex_pb_len; | |
2926 }else{ | |
2927 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
|
2928 s->misc_bits+=17 + pb2_len; |
453 | 2929 s->mv_bits+= bits - s->last_bits; |
2930 s->p_tex_bits+= tex_pb_len; | |
2931 } | |
2932 | |
2933 flush_put_bits(&s->pb2); | |
2934 flush_put_bits(&s->tex_pb); | |
2935 | |
2936 ff_copy_bits(&s->pb, s->pb2_buffer , pb2_len); | |
2937 ff_copy_bits(&s->pb, s->tex_pb_buffer, tex_pb_len); | |
2938 s->last_bits= get_bit_count(&s->pb); | |
2939 } | |
2940 | |
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
|
2941 #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
|
2942 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2943 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
|
2944 switch(s->pict_type){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2945 case I_TYPE: |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2946 return 16; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2947 case P_TYPE: |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2948 case S_TYPE: |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2949 return s->f_code+15; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2950 case B_TYPE: |
847 | 2951 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
|
2952 default: |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2953 return -1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2954 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2955 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2956 |
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
|
2957 #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
|
2958 |
453 | 2959 void ff_mpeg4_encode_video_packet_header(MpegEncContext *s) |
2960 { | |
2961 int mb_num_bits= av_log2(s->mb_num - 1) + 1; | |
2962 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2963 put_bits(&s->pb, ff_mpeg4_get_video_packet_prefix_length(s), 0); |
453 | 2964 put_bits(&s->pb, 1, 1); |
2965 | |
2966 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
|
2967 put_bits(&s->pb, s->quant_precision, s->qscale); |
453 | 2968 put_bits(&s->pb, 1, 0); /* no HEC */ |
2969 } | |
2970 | |
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
|
2971 #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
|
2972 |
453 | 2973 /** |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2974 * 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
|
2975 * @return 0 if not |
453 | 2976 */ |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2977 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
|
2978 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
|
2979 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2980 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
|
2981 return 0; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2982 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2983 |
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
|
2984 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
|
2985 int v= show_bits(&s->gb, 8); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2986 v|= 0x7F >> (7-(bits_count&7)); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2987 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2988 if(v==0x7F) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2989 return 1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2990 }else{ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2991 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
|
2992 int len; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2993 GetBitContext gb= s->gb; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2994 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2995 skip_bits(&s->gb, 1); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2996 align_get_bits(&s->gb); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2997 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2998 for(len=0; len<32; len++){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2999 if(get_bits1(&s->gb)) break; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3000 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3001 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3002 s->gb= gb; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3003 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3004 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
|
3005 return 1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3006 } |
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 return 0; |
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 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3011 /** |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3012 * decodes the next video packet. |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3013 * @return <0 if something went wrong |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3014 */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3015 static int mpeg4_decode_video_packet_header(MpegEncContext *s) |
453 | 3016 { |
290 | 3017 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
|
3018 int header_extension=0, mb_num, len; |
453 | 3019 |
3020 /* 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
|
3021 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
|
3022 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3023 for(len=0; len<32; len++){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3024 if(get_bits1(&s->gb)) break; |
453 | 3025 } |
3026 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3027 if(len!=ff_mpeg4_get_video_packet_prefix_length(s)){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
3028 av_log(s->avctx, AV_LOG_ERROR, "marker does not match f_code\n"); |
453 | 3029 return -1; |
3030 } | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3031 |
453 | 3032 if(s->shape != RECT_SHAPE){ |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3033 header_extension= get_bits1(&s->gb); |
453 | 3034 //FIXME more stuff here |
3035 } | |
3036 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3037 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
|
3038 if(mb_num>=s->mb_num){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
3039 av_log(s->avctx, AV_LOG_ERROR, "illegal mb_num in video packet (%d %d) \n", mb_num, s->mb_num); |
453 | 3040 return -1; |
3041 } | |
1176 | 3042 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
|
3043 while(s->next_picture.mbskip_table[ s->mb_index2xy[ mb_num ] ]) mb_num++; |
1176 | 3044 if(mb_num >= s->mb_num) return -1; // slice contains just skiped MBs which where allready decoded |
3045 } | |
3046 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3047 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
|
3048 s->mb_y= mb_num / s->mb_width; |
453 | 3049 |
3050 if(s->shape != BIN_ONLY_SHAPE){ | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3051 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
|
3052 if(qscale) |
1644 | 3053 s->chroma_qscale=s->qscale= qscale; |
290 | 3054 } |
3055 | |
3056 if(s->shape == RECT_SHAPE){ | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3057 header_extension= get_bits1(&s->gb); |
290 | 3058 } |
3059 if(header_extension){ | |
453 | 3060 int time_increment; |
290 | 3061 int time_incr=0; |
453 | 3062 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3063 while (get_bits1(&s->gb) != 0) |
290 | 3064 time_incr++; |
3065 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3066 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
|
3067 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
|
3068 check_marker(&s->gb, "before vop_coding_type in video packed header"); |
290 | 3069 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3070 skip_bits(&s->gb, 2); /* vop coding type */ |
290 | 3071 //FIXME not rect stuff here |
3072 | |
3073 if(s->shape != BIN_ONLY_SHAPE){ | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3074 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
|
3075 //FIXME dont just ignore everything |
821 | 3076 if(s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE){ |
290 | 3077 mpeg4_decode_sprite_trajectory(s); |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
3078 av_log(s->avctx, AV_LOG_ERROR, "untested\n"); |
290 | 3079 } |
3080 | |
3081 //FIXME reduced res stuff here | |
3082 | |
3083 if (s->pict_type != I_TYPE) { | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3084 int f_code = get_bits(&s->gb, 3); /* fcode_for */ |
660 | 3085 if(f_code==0){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
3086 av_log(s->avctx, AV_LOG_ERROR, "Error, video packet header damaged (f_code=0)\n"); |
290 | 3087 } |
3088 } | |
3089 if (s->pict_type == B_TYPE) { | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3090 int b_code = get_bits(&s->gb, 3); |
660 | 3091 if(b_code==0){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
3092 av_log(s->avctx, AV_LOG_ERROR, "Error, video packet header damaged (b_code=0)\n"); |
660 | 3093 } |
290 | 3094 } |
3095 } | |
3096 } | |
3097 //FIXME new-pred stuff | |
453 | 3098 |
3099 //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)); | |
3100 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3101 return 0; |
453 | 3102 } |
3103 | |
3104 void ff_mpeg4_clean_buffers(MpegEncContext *s) | |
3105 { | |
3106 int c_wrap, c_xy, l_wrap, l_xy; | |
290 | 3107 |
3108 l_wrap= s->block_wrap[0]; | |
453 | 3109 l_xy= s->mb_y*l_wrap*2 + s->mb_x*2; |
290 | 3110 c_wrap= s->block_wrap[4]; |
453 | 3111 c_xy= s->mb_y*c_wrap + s->mb_x; |
290 | 3112 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3113 #if 0 |
290 | 3114 /* clean DC */ |
453 | 3115 memsetw(s->dc_val[0] + l_xy, 1024, l_wrap*2+1); |
3116 memsetw(s->dc_val[1] + c_xy, 1024, c_wrap+1); | |
3117 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
|
3118 #endif |
290 | 3119 |
3120 /* clean AC */ | |
1064 | 3121 memset(s->ac_val[0] + l_xy, 0, (l_wrap*2+1)*16*sizeof(int16_t)); |
3122 memset(s->ac_val[1] + c_xy, 0, (c_wrap +1)*16*sizeof(int16_t)); | |
3123 memset(s->ac_val[2] + c_xy, 0, (c_wrap +1)*16*sizeof(int16_t)); | |
290 | 3124 |
3125 /* clean MV */ | |
453 | 3126 // we cant clear the MVs as they might be needed by a b frame |
1064 | 3127 // memset(s->motion_val + l_xy, 0, (l_wrap*2+1)*2*sizeof(int16_t)); |
3128 // memset(s->motion_val, 0, 2*sizeof(int16_t)*(2 + s->mb_width*2)*(2 + s->mb_height*2)); | |
453 | 3129 s->last_mv[0][0][0]= |
3130 s->last_mv[0][0][1]= | |
3131 s->last_mv[1][0][0]= | |
3132 s->last_mv[1][0][1]= 0; | |
3133 } | |
3134 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3135 /** |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3136 * 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
|
3137 * @return <0 if no resync found |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3138 */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3139 int ff_h263_resync(MpegEncContext *s){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3140 int left, ret; |
453 | 3141 |
1521 | 3142 if(s->codec_id==CODEC_ID_MPEG4){ |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3143 skip_bits1(&s->gb); |
1521 | 3144 align_get_bits(&s->gb); |
3145 } | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3146 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3147 if(show_bits(&s->gb, 16)==0){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3148 if(s->codec_id==CODEC_ID_MPEG4) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3149 ret= mpeg4_decode_video_packet_header(s); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3150 else |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3151 ret= h263_decode_gob_header(s); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3152 if(ret>=0) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3153 return 0; |
453 | 3154 } |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3155 //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
|
3156 s->gb= s->last_resync_gb; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3157 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
|
3158 left= s->gb.size_in_bits - get_bits_count(&s->gb); |
453 | 3159 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3160 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
|
3161 if(show_bits(&s->gb, 16)==0){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3162 GetBitContext bak= s->gb; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3163 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3164 if(s->codec_id==CODEC_ID_MPEG4) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3165 ret= mpeg4_decode_video_packet_header(s); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3166 else |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3167 ret= h263_decode_gob_header(s); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3168 if(ret>=0) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3169 return 0; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3170 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3171 s->gb= bak; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3172 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3173 skip_bits(&s->gb, 8); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3174 } |
1671
a75cbb4588d1
100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l
michael
parents:
1670
diff
changeset
|
3175 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3176 return -1; |
453 | 3177 } |
3178 | |
3179 /** | |
1034 | 3180 * gets the average motion vector for a GMC MB. |
753 | 3181 * @param n either 0 for the x component or 1 for y |
3182 * @returns the average MV for a GMC MB | |
3183 */ | |
3184 static inline int get_amv(MpegEncContext *s, int n){ | |
3185 int x, y, mb_v, sum, dx, dy, shift; | |
3186 int len = 1 << (s->f_code + 4); | |
3187 const int a= s->sprite_warping_accuracy; | |
3188 | |
3189 if(s->real_sprite_warping_points==1){ | |
3190 if(s->divx_version==500 && s->divx_build==413) | |
3191 sum= s->sprite_offset[0][n] / (1<<(a - s->quarter_sample)); | |
3192 else | |
3193 sum= RSHIFT(s->sprite_offset[0][n]<<s->quarter_sample, a); | |
3194 }else{ | |
3195 dx= s->sprite_delta[n][0]; | |
3196 dy= s->sprite_delta[n][1]; | |
3197 shift= s->sprite_shift[0]; | |
3198 if(n) dy -= 1<<(shift + a + 1); | |
3199 else dx -= 1<<(shift + a + 1); | |
3200 mb_v= s->sprite_offset[0][n] + dx*s->mb_x*16 + dy*s->mb_y*16; | |
3201 | |
3202 sum=0; | |
3203 for(y=0; y<16; y++){ | |
3204 int v; | |
3205 | |
3206 v= mb_v + dy*y; | |
3207 //XXX FIXME optimize | |
3208 for(x=0; x<16; x++){ | |
3209 sum+= v>>shift; | |
3210 v+= dx; | |
3211 } | |
3212 } | |
999
74dc4105e147
average motion vector rounding like the reference says and not what the standard says
michaelni
parents:
953
diff
changeset
|
3213 sum= RSHIFT(sum, a+8-s->quarter_sample); |
753 | 3214 } |
3215 | |
3216 if (sum < -len) sum= -len; | |
3217 else if (sum >= len) sum= len-1; | |
3218 | |
3219 return sum; | |
3220 } | |
3221 | |
3222 /** | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3223 * decodes first partition. |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3224 * @return number of MBs decoded or <0 if an error occured |
453 | 3225 */ |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3226 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
|
3227 int mb_num; |
1064 | 3228 static const int8_t quant_tab[4] = { -1, -2, 1, 2 }; |
453 | 3229 |
3230 /* decode first partition */ | |
3231 mb_num=0; | |
290 | 3232 s->first_slice_line=1; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3233 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
|
3234 ff_init_block_index(s); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3235 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
|
3236 const int xy= s->mb_x + s->mb_y*s->mb_stride; |
453 | 3237 int cbpc; |
3238 int dir=0; | |
3239 | |
3240 mb_num++; | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3241 ff_update_block_index(s); |
453 | 3242 if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1) |
3243 s->first_slice_line=0; | |
3244 | |
3245 if(s->pict_type==I_TYPE){ | |
3246 int i; | |
3247 | |
1257 | 3248 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
|
3249 return mb_num-1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3250 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3251 |
1482 | 3252 do{ |
3253 cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2); | |
3254 if (cbpc < 0){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
3255 av_log(s->avctx, AV_LOG_ERROR, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y); |
1482 | 3256 return -1; |
3257 } | |
3258 }while(cbpc == 8); | |
3259 | |
453 | 3260 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
|
3261 s->current_picture.mb_type[xy]= MB_TYPE_INTRA; |
453 | 3262 s->mb_intra = 1; |
3263 | |
3264 if(cbpc & 4) { | |
1652 | 3265 ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]); |
453 | 3266 } |
903 | 3267 s->current_picture.qscale_table[xy]= s->qscale; |
453 | 3268 |
3269 s->mbintra_table[xy]= 1; | |
3270 for(i=0; i<6; i++){ | |
3271 int dc_pred_dir; | |
3272 int dc= mpeg4_decode_dc(s, i, &dc_pred_dir); | |
3273 if(dc < 0){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
3274 av_log(s->avctx, AV_LOG_ERROR, "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
|
3275 return -1; |
453 | 3276 } |
3277 dir<<=1; | |
3278 if(dc_pred_dir) dir|=1; | |
3279 } | |
3280 s->pred_dir_table[xy]= dir; | |
3281 }else{ /* P/S_TYPE */ | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3282 int mx, my, pred_x, pred_y, bits; |
1668
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1666
diff
changeset
|
3283 int16_t * const mot_val= s->current_picture.motion_val[0][s->block_index[0]]; |
453 | 3284 const int stride= s->block_wrap[0]*2; |
3285 | |
1483 | 3286 // do{ //FIXME |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3287 bits= show_bits(&s->gb, 17); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3288 if(bits==MOTION_MARKER){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3289 return mb_num-1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3290 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3291 skip_bits1(&s->gb); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3292 if(bits&0x10000){ |
453 | 3293 /* skip mb */ |
3294 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
|
3295 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0; |
753 | 3296 mx= get_amv(s, 0); |
3297 my= get_amv(s, 1); | |
453 | 3298 }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
|
3299 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0; |
753 | 3300 mx=my=0; |
453 | 3301 } |
3302 mot_val[0 ]= mot_val[2 ]= | |
3303 mot_val[0+stride]= mot_val[2+stride]= mx; | |
3304 mot_val[1 ]= mot_val[3 ]= | |
3305 mot_val[1+stride]= mot_val[3+stride]= my; | |
3306 | |
3307 if(s->mbintra_table[xy]) | |
3308 ff_clean_intra_table_entries(s); | |
3309 continue; | |
3310 } | |
1482 | 3311 |
544 | 3312 cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2); |
453 | 3313 if (cbpc < 0){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
3314 av_log(s->avctx, AV_LOG_ERROR, "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
|
3315 return -1; |
453 | 3316 } |
1483 | 3317 // }while(cbpc == 20); |
1482 | 3318 |
453 | 3319 s->cbp_table[xy]= cbpc&(8+3); //8 is dquant |
3320 | |
3321 s->mb_intra = ((cbpc & 4) != 0); | |
3322 | |
3323 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
|
3324 s->current_picture.mb_type[xy]= MB_TYPE_INTRA; |
453 | 3325 s->mbintra_table[xy]= 1; |
3326 mot_val[0 ]= mot_val[2 ]= | |
3327 mot_val[0+stride]= mot_val[2+stride]= 0; | |
3328 mot_val[1 ]= mot_val[3 ]= | |
3329 mot_val[1+stride]= mot_val[3+stride]= 0; | |
3330 }else{ | |
3331 if(s->mbintra_table[xy]) | |
3332 ff_clean_intra_table_entries(s); | |
3333 | |
3334 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0) | |
3335 s->mcsel= get_bits1(&s->gb); | |
3336 else s->mcsel= 0; | |
3337 | |
3338 if ((cbpc & 16) == 0) { | |
3339 /* 16x16 motion prediction */ | |
3340 | |
3341 h263_pred_motion(s, 0, &pred_x, &pred_y); | |
753 | 3342 if(!s->mcsel){ |
3343 mx = h263_decode_motion(s, pred_x, s->f_code); | |
3344 if (mx >= 0xffff) | |
3345 return -1; | |
3346 | |
3347 my = h263_decode_motion(s, pred_y, s->f_code); | |
3348 if (my >= 0xffff) | |
3349 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
|
3350 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0; |
753 | 3351 } else { |
3352 mx = get_amv(s, 0); | |
3353 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
|
3354 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0; |
453 | 3355 } |
753 | 3356 |
453 | 3357 mot_val[0 ]= mot_val[2 ] = |
3358 mot_val[0+stride]= mot_val[2+stride]= mx; | |
3359 mot_val[1 ]= mot_val[3 ]= | |
3360 mot_val[1+stride]= mot_val[3+stride]= my; | |
3361 } else { | |
3362 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
|
3363 s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0; |
453 | 3364 for(i=0;i<4;i++) { |
1064 | 3365 int16_t *mot_val= h263_pred_motion(s, i, &pred_x, &pred_y); |
453 | 3366 mx = h263_decode_motion(s, pred_x, s->f_code); |
3367 if (mx >= 0xffff) | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3368 return -1; |
453 | 3369 |
3370 my = h263_decode_motion(s, pred_y, s->f_code); | |
3371 if (my >= 0xffff) | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3372 return -1; |
453 | 3373 mot_val[0] = mx; |
3374 mot_val[1] = my; | |
3375 } | |
3376 } | |
3377 } | |
3378 } | |
3379 } | |
3380 s->mb_x= 0; | |
3381 } | |
3382 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3383 return mb_num; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3384 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3385 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3386 /** |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3387 * decode second partition. |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3388 * @return <0 if an error occured |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3389 */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3390 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
|
3391 int mb_num=0; |
1064 | 3392 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
|
3393 |
453 | 3394 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
|
3395 s->first_slice_line=1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3396 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
|
3397 ff_init_block_index(s); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3398 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
|
3399 const int xy= s->mb_x + s->mb_y*s->mb_stride; |
453 | 3400 |
3401 mb_num++; | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3402 ff_update_block_index(s); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3403 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
|
3404 s->first_slice_line=0; |
453 | 3405 |
3406 if(s->pict_type==I_TYPE){ | |
3407 int ac_pred= get_bits1(&s->gb); | |
544 | 3408 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1); |
453 | 3409 if(cbpy<0){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
3410 av_log(s->avctx, AV_LOG_ERROR, "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
|
3411 return -1; |
453 | 3412 } |
3413 | |
3414 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
|
3415 s->current_picture.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED; |
453 | 3416 }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
|
3417 if(IS_INTRA(s->current_picture.mb_type[xy])){ |
453 | 3418 int dir=0,i; |
3419 int ac_pred = get_bits1(&s->gb); | |
544 | 3420 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1); |
453 | 3421 |
3422 if(cbpy<0){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
3423 av_log(s->avctx, AV_LOG_ERROR, "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
|
3424 return -1; |
453 | 3425 } |
3426 | |
3427 if(s->cbp_table[xy] & 8) { | |
1652 | 3428 ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]); |
453 | 3429 } |
903 | 3430 s->current_picture.qscale_table[xy]= s->qscale; |
453 | 3431 |
3432 for(i=0; i<6; i++){ | |
3433 int dc_pred_dir; | |
3434 int dc= mpeg4_decode_dc(s, i, &dc_pred_dir); | |
3435 if(dc < 0){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
3436 av_log(s->avctx, AV_LOG_ERROR, "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
|
3437 return -1; |
453 | 3438 } |
3439 dir<<=1; | |
3440 if(dc_pred_dir) dir|=1; | |
3441 } | |
3442 s->cbp_table[xy]&= 3; //remove dquant | |
3443 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
|
3444 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
|
3445 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
|
3446 }else if(IS_SKIP(s->current_picture.mb_type[xy])){ |
903 | 3447 s->current_picture.qscale_table[xy]= s->qscale; |
453 | 3448 s->cbp_table[xy]= 0; |
3449 }else{ | |
544 | 3450 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1); |
453 | 3451 |
3452 if(cbpy<0){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
3453 av_log(s->avctx, AV_LOG_ERROR, "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
|
3454 return -1; |
453 | 3455 } |
3456 | |
3457 if(s->cbp_table[xy] & 8) { | |
1652 | 3458 ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]); |
453 | 3459 } |
903 | 3460 s->current_picture.qscale_table[xy]= s->qscale; |
453 | 3461 |
3462 s->cbp_table[xy]&= 3; //remove dquant | |
3463 s->cbp_table[xy]|= (cbpy^0xf)<<2; | |
3464 } | |
3465 } | |
3466 } | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3467 if(mb_num >= mb_count) return 0; |
453 | 3468 s->mb_x= 0; |
3469 } | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3470 return 0; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3471 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3472 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3473 /** |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3474 * decodes the first & second partition |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3475 * @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
|
3476 */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3477 int ff_mpeg4_decode_partitions(MpegEncContext *s) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3478 { |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3479 int mb_num; |
1144 | 3480 const int part_a_error= s->pict_type==I_TYPE ? (DC_ERROR|MV_ERROR) : MV_ERROR; |
3481 const int part_a_end = s->pict_type==I_TYPE ? (DC_END |MV_END) : MV_END; | |
453 | 3482 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3483 mb_num= mpeg4_decode_partition_a(s); |
1144 | 3484 if(mb_num<0){ |
3485 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
|
3486 return -1; |
1144 | 3487 } |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3488 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3489 if(s->resync_mb_x + s->resync_mb_y*s->mb_width + mb_num > s->mb_num){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
3490 av_log(s->avctx, AV_LOG_ERROR, "slice below monitor ...\n"); |
1144 | 3491 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
|
3492 return -1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3493 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3494 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3495 s->mb_num_left= mb_num; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3496 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3497 if(s->pict_type==I_TYPE){ |
1257 | 3498 if(get_bits_long(&s->gb, 19)!=DC_MARKER){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
3499 av_log(s->avctx, AV_LOG_ERROR, "marker missing after first I partition 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
|
3500 return -1; |
1144 | 3501 } |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3502 }else{ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3503 if(get_bits(&s->gb, 17)!=MOTION_MARKER){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
3504 av_log(s->avctx, AV_LOG_ERROR, "marker missing after first P partition 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
|
3505 return -1; |
1144 | 3506 } |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3507 } |
1144 | 3508 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
|
3509 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3510 if( mpeg4_decode_partition_b(s, mb_num) < 0){ |
1144 | 3511 if(s->pict_type==P_TYPE) |
3512 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
|
3513 return -1; |
1144 | 3514 }else{ |
3515 if(s->pict_type==P_TYPE) | |
3516 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
|
3517 } |
453 | 3518 |
3519 return 0; | |
3520 } | |
3521 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3522 /** |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3523 * decode partition C of one MB. |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3524 * @return <0 if an error occured |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3525 */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3526 static int mpeg4_decode_partitioned_mb(MpegEncContext *s, DCTELEM block[6][64]) |
453 | 3527 { |
3528 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
|
3529 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
|
3530 |
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
|
3531 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
|
3532 cbp = s->cbp_table[xy]; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3533 |
903 | 3534 if(s->current_picture.qscale_table[xy] != s->qscale){ |
1652 | 3535 ff_set_qscale(s, s->current_picture.qscale_table[xy] ); |
453 | 3536 } |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3537 |
453 | 3538 if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) { |
3539 int i; | |
3540 for(i=0; i<4; i++){ | |
1668
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1666
diff
changeset
|
3541 s->mv[0][i][0] = s->current_picture.motion_val[0][ s->block_index[i] ][0]; |
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1666
diff
changeset
|
3542 s->mv[0][i][1] = s->current_picture.motion_val[0][ s->block_index[i] ][1]; |
453 | 3543 } |
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
|
3544 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
|
3545 |
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
|
3546 if (IS_SKIP(mb_type)) { |
453 | 3547 /* skip mb */ |
3548 for(i=0;i<6;i++) | |
3549 s->block_last_index[i] = -1; | |
3550 s->mv_dir = MV_DIR_FORWARD; | |
3551 s->mv_type = MV_TYPE_16X16; | |
3552 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){ | |
3553 s->mcsel=1; | |
3554 s->mb_skiped = 0; | |
3555 }else{ | |
3556 s->mcsel=0; | |
3557 s->mb_skiped = 1; | |
3558 } | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3559 }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
|
3560 s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]); |
453 | 3561 }else if(!s->mb_intra){ |
3562 // s->mcsel= 0; //FIXME do we need to init that | |
3563 | |
3564 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
|
3565 if (IS_8X8(mb_type)) { |
453 | 3566 s->mv_type = MV_TYPE_8X8; |
3567 } else { | |
3568 s->mv_type = MV_TYPE_16X16; | |
3569 } | |
3570 } | |
3571 } else { /* I-Frame */ | |
3572 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
|
3573 s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]); |
1132 | 3574 } |
3575 | |
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
|
3576 if (!IS_SKIP(mb_type)) { |
1132 | 3577 int i; |
453 | 3578 /* decode each block */ |
3579 for (i = 0; i < 6; i++) { | |
1132 | 3580 if(mpeg4_decode_block(s, block[i], i, cbp&32, s->mb_intra, s->rvlc) < 0){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
3581 av_log(s->avctx, AV_LOG_ERROR, "texture corrupted at %d %d %d\n", s->mb_x, s->mb_y, s->mb_intra); |
453 | 3582 return -1; |
3583 } | |
718 | 3584 cbp+=cbp; |
453 | 3585 } |
3586 } | |
290 | 3587 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3588 /* per-MB end of slice check */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3589 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3590 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
|
3591 //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
|
3592 if(mpeg4_is_resync(s)) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3593 return SLICE_END; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3594 else |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3595 return SLICE_NOEND; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3596 }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
|
3597 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
|
3598 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
|
3599 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
|
3600 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
|
3601 } |
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
|
3602 return SLICE_OK; |
619
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3603 } |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3604 } |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3605 |
1633 | 3606 /** |
3607 * read the next MVs for OBMC. yes this is a ugly hack, feel free to send a patch :) | |
3608 */ | |
3609 static void preview_obmc(MpegEncContext *s){ | |
3610 GetBitContext gb= s->gb; | |
3611 | |
3612 int cbpc, i, pred_x, pred_y, mx, my; | |
3613 int16_t *mot_val; | |
3614 const int xy= s->mb_x + 1 + s->mb_y * s->mb_stride; | |
3615 const int stride= s->block_wrap[0]*2; | |
3616 | |
3617 for(i=0; i<4; i++) | |
3618 s->block_index[i]+= 2; | |
3619 for(i=4; i<6; i++) | |
3620 s->block_index[i]+= 1; | |
3621 s->mb_x++; | |
3622 | |
3623 assert(s->pict_type == P_TYPE); | |
3624 | |
3625 do{ | |
3626 if (get_bits1(&s->gb)) { | |
3627 /* skip mb */ | |
1668
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1666
diff
changeset
|
3628 mot_val = s->current_picture.motion_val[0][ s->block_index[0] ]; |
1633 | 3629 mot_val[0 ]= mot_val[2 ]= |
3630 mot_val[0+stride]= mot_val[2+stride]= 0; | |
3631 mot_val[1 ]= mot_val[3 ]= | |
3632 mot_val[1+stride]= mot_val[3+stride]= 0; | |
3633 | |
3634 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0; | |
3635 goto end; | |
3636 } | |
3637 cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2); | |
3638 }while(cbpc == 20); | |
3639 | |
3640 if(cbpc & 4){ | |
3641 s->current_picture.mb_type[xy]= MB_TYPE_INTRA; | |
3642 }else{ | |
3643 get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1); | |
3644 if (cbpc & 8) { | |
1656 | 3645 if(s->modified_quant){ |
3646 if(get_bits1(&s->gb)) skip_bits(&s->gb, 1); | |
3647 else skip_bits(&s->gb, 5); | |
3648 }else | |
3649 skip_bits(&s->gb, 2); | |
1633 | 3650 } |
3651 | |
3652 if ((cbpc & 16) == 0) { | |
3653 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0; | |
3654 /* 16x16 motion prediction */ | |
3655 mot_val= h263_pred_motion(s, 0, &pred_x, &pred_y); | |
3656 if (s->umvplus) | |
3657 mx = h263p_decode_umotion(s, pred_x); | |
3658 else | |
1655 | 3659 mx = h263_decode_motion(s, pred_x, 1); |
1633 | 3660 |
3661 if (s->umvplus) | |
3662 my = h263p_decode_umotion(s, pred_y); | |
3663 else | |
1655 | 3664 my = h263_decode_motion(s, pred_y, 1); |
1633 | 3665 |
3666 mot_val[0 ]= mot_val[2 ]= | |
3667 mot_val[0+stride]= mot_val[2+stride]= mx; | |
3668 mot_val[1 ]= mot_val[3 ]= | |
3669 mot_val[1+stride]= mot_val[3+stride]= my; | |
3670 } else { | |
3671 s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0; | |
3672 for(i=0;i<4;i++) { | |
3673 mot_val = h263_pred_motion(s, i, &pred_x, &pred_y); | |
3674 if (s->umvplus) | |
3675 mx = h263p_decode_umotion(s, pred_x); | |
3676 else | |
1655 | 3677 mx = h263_decode_motion(s, pred_x, 1); |
1633 | 3678 |
3679 if (s->umvplus) | |
3680 my = h263p_decode_umotion(s, pred_y); | |
3681 else | |
1655 | 3682 my = h263_decode_motion(s, pred_y, 1); |
1633 | 3683 if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1) |
3684 skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */ | |
3685 mot_val[0] = mx; | |
3686 mot_val[1] = my; | |
3687 } | |
3688 } | |
3689 } | |
3690 end: | |
3691 | |
3692 for(i=0; i<4; i++) | |
3693 s->block_index[i]-= 2; | |
3694 for(i=4; i<6; i++) | |
3695 s->block_index[i]-= 1; | |
3696 s->mb_x--; | |
3697 | |
3698 s->gb= gb; | |
3699 } | |
3700 | |
1656 | 3701 static void h263_decode_dquant(MpegEncContext *s){ |
3702 static const int8_t quant_tab[4] = { -1, -2, 1, 2 }; | |
3703 | |
3704 if(s->modified_quant){ | |
3705 if(get_bits1(&s->gb)) | |
3706 s->qscale= modified_quant_tab[get_bits1(&s->gb)][ s->qscale ]; | |
3707 else | |
3708 s->qscale= get_bits(&s->gb, 5); | |
3709 }else | |
3710 s->qscale += quant_tab[get_bits(&s->gb, 2)]; | |
3711 ff_set_qscale(s, s->qscale); | |
3712 } | |
3713 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3714 int ff_h263_decode_mb(MpegEncContext *s, |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3715 DCTELEM block[6][64]) |
0 | 3716 { |
3717 int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant; | |
1064 | 3718 int16_t *mot_val; |
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
|
3719 const int xy= s->mb_x + s->mb_y * s->mb_stride; |
1521 | 3720 |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3721 assert(!s->h263_pred); |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3722 |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3723 if (s->pict_type == P_TYPE) { |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3724 do{ |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3725 if (get_bits1(&s->gb)) { |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3726 /* skip mb */ |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3727 s->mb_intra = 0; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3728 for(i=0;i<6;i++) |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3729 s->block_last_index[i] = -1; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3730 s->mv_dir = MV_DIR_FORWARD; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3731 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
|
3732 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0; |
255 | 3733 s->mv[0][0][0] = 0; |
3734 s->mv[0][0][1] = 0; | |
1644 | 3735 s->mb_skiped = !(s->obmc | s->loop_filter); |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3736 goto end; |
255 | 3737 } |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3738 cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2); |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3739 //fprintf(stderr, "\tCBPC: %d", cbpc); |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3740 if (cbpc < 0){ |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3741 av_log(s->avctx, AV_LOG_ERROR, "cbpc damaged at %d %d\n", s->mb_x, s->mb_y); |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3742 return -1; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3743 } |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3744 }while(cbpc == 20); |
144 | 3745 |
0 | 3746 dquant = cbpc & 8; |
3747 s->mb_intra = ((cbpc & 4) != 0); | |
262 | 3748 if (s->mb_intra) goto intra; |
3749 | |
544 | 3750 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1); |
1637 | 3751 |
3752 if(s->alt_inter_vlc==0 || (cbpc & 3)!=3) | |
3753 cbpy ^= 0xF; | |
3754 | |
3755 cbp = (cbpc & 3) | (cbpy << 2); | |
0 | 3756 if (dquant) { |
1656 | 3757 h263_decode_dquant(s); |
0 | 3758 } |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3759 |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3760 s->mv_dir = MV_DIR_FORWARD; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3761 if ((cbpc & 16) == 0) { |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3762 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3763 /* 16x16 motion prediction */ |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3764 s->mv_type = MV_TYPE_16X16; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3765 h263_pred_motion(s, 0, &pred_x, &pred_y); |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3766 if (s->umvplus) |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3767 mx = h263p_decode_umotion(s, pred_x); |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3768 else |
1655 | 3769 mx = h263_decode_motion(s, pred_x, 1); |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3770 |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3771 if (mx >= 0xffff) |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3772 return -1; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3773 |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3774 if (s->umvplus) |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3775 my = h263p_decode_umotion(s, pred_y); |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3776 else |
1655 | 3777 my = h263_decode_motion(s, pred_y, 1); |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3778 |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3779 if (my >= 0xffff) |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3780 return -1; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3781 s->mv[0][0][0] = mx; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3782 s->mv[0][0][1] = my; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3783 |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3784 if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1) |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3785 skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */ |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3786 } else { |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3787 s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3788 s->mv_type = MV_TYPE_8X8; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3789 for(i=0;i<4;i++) { |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3790 mot_val = h263_pred_motion(s, i, &pred_x, &pred_y); |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3791 if (s->umvplus) |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3792 mx = h263p_decode_umotion(s, pred_x); |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3793 else |
1655 | 3794 mx = h263_decode_motion(s, pred_x, 1); |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3795 if (mx >= 0xffff) |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3796 return -1; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3797 |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3798 if (s->umvplus) |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3799 my = h263p_decode_umotion(s, pred_y); |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3800 else |
1655 | 3801 my = h263_decode_motion(s, pred_y, 1); |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3802 if (my >= 0xffff) |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3803 return -1; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3804 s->mv[0][i][0] = mx; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3805 s->mv[0][i][1] = my; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3806 if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1) |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3807 skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */ |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3808 mot_val[0] = mx; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3809 mot_val[1] = my; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3810 } |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3811 } |
1655 | 3812 |
3813 if(s->obmc){ | |
3814 if(s->pict_type == P_TYPE && s->mb_x+1<s->mb_width) | |
3815 preview_obmc(s); | |
3816 } | |
3817 } else if(s->pict_type==B_TYPE) { | |
3818 int mb_type; | |
3819 const int stride= s->b8_stride; | |
3820 int16_t *mot_val0 = s->current_picture.motion_val[0][ s->mb_x + s->mb_y*stride ]; | |
3821 int16_t *mot_val1 = s->current_picture.motion_val[1][ s->mb_x + s->mb_y*stride ]; | |
3822 // const int mv_xy= s->mb_x + 1 + s->mb_y * s->mb_stride; | |
3823 | |
3824 //FIXME ugly | |
3825 mot_val0[0 ]= mot_val0[2 ]= mot_val0[0+stride]= mot_val0[2+stride]= 0; | |
3826 mot_val0[1 ]= mot_val0[3 ]= mot_val0[1+stride]= mot_val0[3+stride]= 0; | |
3827 mot_val1[0 ]= mot_val1[2 ]= mot_val1[0+stride]= mot_val1[2+stride]= 0; | |
3828 mot_val1[1 ]= mot_val1[3 ]= mot_val1[1+stride]= mot_val1[3+stride]= 0; | |
3829 | |
3830 do{ | |
3831 mb_type= get_vlc2(&s->gb, h263_mbtype_b_vlc.table, H263_MBTYPE_B_VLC_BITS, 2); | |
3832 if (mb_type < 0){ | |
3833 av_log(s->avctx, AV_LOG_ERROR, "b mb_type damaged at %d %d\n", s->mb_x, s->mb_y); | |
3834 return -1; | |
3835 } | |
3836 | |
3837 mb_type= h263_mb_type_b_map[ mb_type ]; | |
3838 }while(!mb_type); | |
3839 | |
3840 s->mb_intra = IS_INTRA(mb_type); | |
3841 if(HAS_CBP(mb_type)){ | |
3842 cbpc = get_vlc2(&s->gb, cbpc_b_vlc.table, CBPC_B_VLC_BITS, 1); | |
3843 if(s->mb_intra){ | |
3844 dquant = IS_QUANT(mb_type); | |
3845 goto intra; | |
3846 } | |
3847 | |
3848 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1); | |
3849 | |
3850 if (cbpy < 0){ | |
3851 av_log(s->avctx, AV_LOG_ERROR, "b cbpy damaged at %d %d\n", s->mb_x, s->mb_y); | |
3852 return -1; | |
3853 } | |
3854 | |
3855 if(s->alt_inter_vlc==0 || (cbpc & 3)!=3) | |
3856 cbpy ^= 0xF; | |
3857 | |
3858 cbp = (cbpc & 3) | (cbpy << 2); | |
3859 }else | |
3860 cbp=0; | |
3861 | |
3862 assert(!s->mb_intra); | |
3863 | |
3864 if(IS_QUANT(mb_type)){ | |
1656 | 3865 h263_decode_dquant(s); |
1655 | 3866 } |
3867 | |
3868 if(IS_DIRECT(mb_type)){ | |
3869 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT; | |
3870 mb_type |= ff_mpeg4_set_direct_mv(s, 0, 0); | |
3871 }else{ | |
3872 s->mv_dir = 0; | |
3873 s->mv_type= MV_TYPE_16X16; | |
3874 //FIXME UMV | |
3875 | |
3876 if(USES_LIST(mb_type, 0)){ | |
3877 int16_t *mot_val= h263_pred_motion2(s, 0, 0, &mx, &my); | |
3878 s->mv_dir = MV_DIR_FORWARD; | |
3879 | |
3880 mx = h263_decode_motion(s, mx, 1); | |
3881 my = h263_decode_motion(s, my, 1); | |
3882 s->mv[0][0][0] = mx; | |
3883 s->mv[0][0][1] = my; | |
3884 mot_val[0 ]= mot_val[2 ]= mot_val[0+stride]= mot_val[2+stride]= mx; | |
3885 mot_val[1 ]= mot_val[3 ]= mot_val[1+stride]= mot_val[3+stride]= my; | |
3886 } | |
3887 | |
3888 if(USES_LIST(mb_type, 1)){ | |
3889 int16_t *mot_val= h263_pred_motion2(s, 0, 1, &mx, &my); | |
3890 s->mv_dir |= MV_DIR_BACKWARD; | |
3891 | |
3892 mx = h263_decode_motion(s, mx, 1); | |
3893 my = h263_decode_motion(s, my, 1); | |
3894 s->mv[1][0][0] = mx; | |
3895 s->mv[1][0][1] = my; | |
3896 mot_val[0 ]= mot_val[2 ]= mot_val[0+stride]= mot_val[2+stride]= mx; | |
3897 mot_val[1 ]= mot_val[3 ]= mot_val[1+stride]= mot_val[3+stride]= my; | |
3898 } | |
3899 } | |
3900 | |
3901 s->current_picture.mb_type[xy]= mb_type; | |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3902 } else { /* I-Frame */ |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3903 do{ |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3904 cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2); |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3905 if (cbpc < 0){ |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3906 av_log(s->avctx, AV_LOG_ERROR, "I cbpc damaged at %d %d\n", s->mb_x, s->mb_y); |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3907 return -1; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3908 } |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3909 }while(cbpc == 8); |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3910 |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3911 dquant = cbpc & 4; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3912 s->mb_intra = 1; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3913 intra: |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3914 s->current_picture.mb_type[xy]= MB_TYPE_INTRA; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3915 if (s->h263_aic) { |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3916 s->ac_pred = get_bits1(&s->gb); |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3917 if(s->ac_pred){ |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3918 s->current_picture.mb_type[xy]= MB_TYPE_INTRA | MB_TYPE_ACPRED; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3919 |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3920 s->h263_aic_dir = get_bits1(&s->gb); |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3921 } |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3922 }else |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3923 s->ac_pred = 0; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3924 |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3925 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1); |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3926 if(cbpy<0){ |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3927 av_log(s->avctx, AV_LOG_ERROR, "I cbpy damaged at %d %d\n", s->mb_x, s->mb_y); |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3928 return -1; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3929 } |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3930 cbp = (cbpc & 3) | (cbpy << 2); |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3931 if (dquant) { |
1656 | 3932 h263_decode_dquant(s); |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3933 } |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3934 } |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3935 |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3936 /* decode each block */ |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3937 for (i = 0; i < 6; i++) { |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3938 if (h263_decode_block(s, block[i], i, cbp&32) < 0) |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3939 return -1; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3940 cbp+=cbp; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3941 } |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3942 end: |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3943 |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3944 /* per-MB end of slice check */ |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3945 { |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3946 int v= show_bits(&s->gb, 16); |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3947 |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3948 if(get_bits_count(&s->gb) + 16 > s->gb.size_in_bits){ |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3949 v>>= get_bits_count(&s->gb) + 16 - s->gb.size_in_bits; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3950 } |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3951 |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3952 if(v==0) |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3953 return SLICE_END; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3954 } |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3955 |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3956 return SLICE_OK; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3957 } |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3958 |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3959 int ff_mpeg4_decode_mb(MpegEncContext *s, |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3960 DCTELEM block[6][64]) |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3961 { |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3962 int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3963 int16_t *mot_val; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3964 static int8_t quant_tab[4] = { -1, -2, 1, 2 }; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3965 const int xy= s->mb_x + s->mb_y * s->mb_stride; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3966 |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3967 assert(s->h263_pred); |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3968 |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3969 if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) { |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3970 do{ |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3971 if (get_bits1(&s->gb)) { |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3972 /* skip mb */ |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3973 s->mb_intra = 0; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3974 for(i=0;i<6;i++) |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3975 s->block_last_index[i] = -1; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3976 s->mv_dir = MV_DIR_FORWARD; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3977 s->mv_type = MV_TYPE_16X16; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3978 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){ |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3979 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_GMC | MB_TYPE_16x16 | MB_TYPE_L0; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3980 s->mcsel=1; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3981 s->mv[0][0][0]= get_amv(s, 0); |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3982 s->mv[0][0][1]= get_amv(s, 1); |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3983 |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3984 s->mb_skiped = 0; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3985 }else{ |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3986 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3987 s->mcsel=0; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3988 s->mv[0][0][0] = 0; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3989 s->mv[0][0][1] = 0; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3990 s->mb_skiped = 1; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3991 } |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3992 goto end; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3993 } |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3994 cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2); |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3995 //fprintf(stderr, "\tCBPC: %d", cbpc); |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3996 if (cbpc < 0){ |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3997 av_log(s->avctx, AV_LOG_ERROR, "cbpc damaged at %d %d\n", s->mb_x, s->mb_y); |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3998 return -1; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3999 } |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4000 }while(cbpc == 20); |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4001 |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4002 dquant = cbpc & 8; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4003 s->mb_intra = ((cbpc & 4) != 0); |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4004 if (s->mb_intra) goto intra; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4005 |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4006 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0) |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4007 s->mcsel= get_bits1(&s->gb); |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4008 else s->mcsel= 0; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4009 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1) ^ 0x0F; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4010 |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4011 cbp = (cbpc & 3) | (cbpy << 2); |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4012 if (dquant) { |
1652 | 4013 ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]); |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4014 } |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4015 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
|
4016 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
|
4017 |
0 | 4018 s->mv_dir = MV_DIR_FORWARD; |
4019 if ((cbpc & 16) == 0) { | |
619
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4020 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
|
4021 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
|
4022 /* 16x16 global motion prediction */ |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4023 s->mv_type = MV_TYPE_16X16; |
753 | 4024 mx= get_amv(s, 0); |
4025 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
|
4026 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
|
4027 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
|
4028 }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
|
4029 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
|
4030 /* 16x8 field motion prediction */ |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4031 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
|
4032 |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4033 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
|
4034 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
|
4035 |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4036 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
|
4037 |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4038 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
|
4039 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
|
4040 if (mx >= 0xffff) |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4041 return -1; |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4042 |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4043 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
|
4044 if (my >= 0xffff) |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4045 return -1; |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4046 |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4047 s->mv[0][i][0] = mx; |
661 | 4048 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
|
4049 } |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4050 }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
|
4051 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
|
4052 /* 16x16 motion prediction */ |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4053 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
|
4054 h263_pred_motion(s, 0, &pred_x, &pred_y); |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4055 mx = h263_decode_motion(s, pred_x, s->f_code); |
619
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4056 |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4057 if (mx >= 0xffff) |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4058 return -1; |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4059 |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4060 my = h263_decode_motion(s, pred_y, s->f_code); |
619
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4061 |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4062 if (my >= 0xffff) |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4063 return -1; |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4064 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
|
4065 s->mv[0][0][1] = my; |
255 | 4066 } |
0 | 4067 } 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
|
4068 s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0; |
0 | 4069 s->mv_type = MV_TYPE_8X8; |
4070 for(i=0;i<4;i++) { | |
4071 mot_val = h263_pred_motion(s, i, &pred_x, &pred_y); | |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4072 mx = h263_decode_motion(s, pred_x, s->f_code); |
0 | 4073 if (mx >= 0xffff) |
4074 return -1; | |
78 | 4075 |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4076 my = h263_decode_motion(s, pred_y, s->f_code); |
0 | 4077 if (my >= 0xffff) |
4078 return -1; | |
4079 s->mv[0][i][0] = mx; | |
4080 s->mv[0][i][1] = my; | |
4081 mot_val[0] = mx; | |
4082 mot_val[1] = my; | |
4083 } | |
4084 } | |
262 | 4085 } else if(s->pict_type==B_TYPE) { |
4086 int modb1; // first bit of modb | |
4087 int modb2; // second bit of modb | |
4088 int mb_type; | |
4089 | |
4090 s->mb_intra = 0; //B-frames never contain intra blocks | |
4091 s->mcsel=0; // ... true gmc blocks | |
4092 | |
4093 if(s->mb_x==0){ | |
674 | 4094 for(i=0; i<2; i++){ |
4095 s->last_mv[i][0][0]= | |
4096 s->last_mv[i][0][1]= | |
4097 s->last_mv[i][1][0]= | |
4098 s->last_mv[i][1][1]= 0; | |
4099 } | |
262 | 4100 } |
4101 | |
4102 /* 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
|
4103 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 | 4104 |
4105 if(s->mb_skiped){ | |
4106 /* skip mb */ | |
4107 for(i=0;i<6;i++) | |
4108 s->block_last_index[i] = -1; | |
4109 | |
4110 s->mv_dir = MV_DIR_FORWARD; | |
4111 s->mv_type = MV_TYPE_16X16; | |
4112 s->mv[0][0][0] = 0; | |
4113 s->mv[0][0][1] = 0; | |
4114 s->mv[1][0][0] = 0; | |
4115 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
|
4116 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
|
4117 goto end; |
262 | 4118 } |
4119 | |
666 | 4120 modb1= get_bits1(&s->gb); |
4121 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
|
4122 mb_type= MB_TYPE_DIRECT2 | MB_TYPE_SKIP | MB_TYPE_L0L1; //like MB_TYPE_B_DIRECT but no vectors coded |
666 | 4123 cbp=0; |
4124 }else{ | |
262 | 4125 modb2= get_bits1(&s->gb); |
544 | 4126 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
|
4127 if(mb_type<0){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
4128 av_log(s->avctx, AV_LOG_ERROR, "illegal MB_type\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
|
4129 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
|
4130 } |
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
|
4131 mb_type= mb_type_b_map[ mb_type ]; |
666 | 4132 if(modb2) cbp= 0; |
4133 else cbp= get_bits(&s->gb, 6); | |
4134 | |
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
|
4135 if ((!IS_DIRECT(mb_type)) && cbp) { |
262 | 4136 if(get_bits1(&s->gb)){ |
1652 | 4137 ff_set_qscale(s, s->qscale + get_bits1(&s->gb)*4 - 2); |
262 | 4138 } |
4139 } | |
664 | 4140 |
4141 if(!s->progressive_sequence){ | |
4142 if(cbp) | |
4143 s->interlaced_dct= get_bits1(&s->gb); | |
4144 | |
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
|
4145 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
|
4146 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
|
4147 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
|
4148 |
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
|
4149 if(USES_LIST(mb_type, 0)){ |
667 | 4150 s->field_select[0][0]= get_bits1(&s->gb); |
4151 s->field_select[0][1]= get_bits1(&s->gb); | |
4152 } | |
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
|
4153 if(USES_LIST(mb_type, 1)){ |
667 | 4154 s->field_select[1][0]= get_bits1(&s->gb); |
4155 s->field_select[1][1]= get_bits1(&s->gb); | |
4156 } | |
4157 } | |
666 | 4158 } |
4159 | |
667 | 4160 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
|
4161 if((mb_type & (MB_TYPE_DIRECT2|MB_TYPE_INTERLACED)) == 0){ |
666 | 4162 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
|
4163 |
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
|
4164 if(USES_LIST(mb_type, 0)){ |
666 | 4165 s->mv_dir = MV_DIR_FORWARD; |
4166 | |
4167 mx = h263_decode_motion(s, s->last_mv[0][0][0], s->f_code); | |
4168 my = h263_decode_motion(s, s->last_mv[0][0][1], s->f_code); | |
4169 s->last_mv[0][1][0]= s->last_mv[0][0][0]= s->mv[0][0][0] = mx; | |
4170 s->last_mv[0][1][1]= s->last_mv[0][0][1]= s->mv[0][0][1] = my; | |
667 | 4171 } |
666 | 4172 |
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
|
4173 if(USES_LIST(mb_type, 1)){ |
666 | 4174 s->mv_dir |= MV_DIR_BACKWARD; |
4175 | |
4176 mx = h263_decode_motion(s, s->last_mv[1][0][0], s->b_code); | |
4177 my = h263_decode_motion(s, s->last_mv[1][0][1], s->b_code); | |
4178 s->last_mv[1][1][0]= s->last_mv[1][0][0]= s->mv[1][0][0] = mx; | |
4179 s->last_mv[1][1][1]= s->last_mv[1][0][1]= s->mv[1][0][1] = my; | |
4180 } | |
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
|
4181 }else if(!IS_DIRECT(mb_type)){ |
666 | 4182 s->mv_type= MV_TYPE_FIELD; |
667 | 4183 |
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
|
4184 if(USES_LIST(mb_type, 0)){ |
666 | 4185 s->mv_dir = MV_DIR_FORWARD; |
4186 | |
4187 for(i=0; i<2; i++){ | |
4188 mx = h263_decode_motion(s, s->last_mv[0][i][0] , s->f_code); | |
4189 my = h263_decode_motion(s, s->last_mv[0][i][1]/2, s->f_code); | |
4190 s->last_mv[0][i][0]= s->mv[0][i][0] = mx; | |
4191 s->last_mv[0][i][1]= (s->mv[0][i][1] = my)*2; | |
4192 } | |
667 | 4193 } |
666 | 4194 |
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
|
4195 if(USES_LIST(mb_type, 1)){ |
666 | 4196 s->mv_dir |= MV_DIR_BACKWARD; |
4197 | |
4198 for(i=0; i<2; i++){ | |
4199 mx = h263_decode_motion(s, s->last_mv[1][i][0] , s->b_code); | |
4200 my = h263_decode_motion(s, s->last_mv[1][i][1]/2, s->b_code); | |
4201 s->last_mv[1][i][0]= s->mv[1][i][0] = mx; | |
4202 s->last_mv[1][i][1]= (s->mv[1][i][1] = my)*2; | |
664 | 4203 } |
4204 } | |
4205 } | |
4206 } | |
666 | 4207 |
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
|
4208 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
|
4209 if(IS_SKIP(mb_type)) |
666 | 4210 mx=my=0; |
4211 else{ | |
4212 mx = h263_decode_motion(s, 0, 1); | |
4213 my = h263_decode_motion(s, 0, 1); | |
4214 } | |
664 | 4215 |
262 | 4216 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
|
4217 mb_type |= ff_mpeg4_set_direct_mv(s, mx, my); |
664 | 4218 } |
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
|
4219 s->current_picture.mb_type[xy]= mb_type; |
262 | 4220 } else { /* I-Frame */ |
1482 | 4221 do{ |
4222 cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2); | |
4223 if (cbpc < 0){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
4224 av_log(s->avctx, AV_LOG_ERROR, "I cbpc damaged at %d %d\n", s->mb_x, s->mb_y); |
1482 | 4225 return -1; |
4226 } | |
4227 }while(cbpc == 8); | |
4228 | |
262 | 4229 dquant = cbpc & 4; |
4230 s->mb_intra = 1; | |
4231 intra: | |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4232 s->ac_pred = get_bits1(&s->gb); |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4233 if(s->ac_pred) |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4234 s->current_picture.mb_type[xy]= MB_TYPE_INTRA | MB_TYPE_ACPRED; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4235 else |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4236 s->current_picture.mb_type[xy]= MB_TYPE_INTRA; |
591 | 4237 |
544 | 4238 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1); |
1482 | 4239 if(cbpy<0){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
4240 av_log(s->avctx, AV_LOG_ERROR, "I cbpy damaged at %d %d\n", s->mb_x, s->mb_y); |
1482 | 4241 return -1; |
4242 } | |
0 | 4243 cbp = (cbpc & 3) | (cbpy << 2); |
4244 if (dquant) { | |
1652 | 4245 ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]); |
0 | 4246 } |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4247 |
619
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4248 if(!s->progressive_sequence) |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4249 s->interlaced_dct= get_bits1(&s->gb); |
575 | 4250 |
4251 /* decode each block */ | |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4252 for (i = 0; i < 6; i++) { |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4253 if (mpeg4_decode_block(s, block[i], i, cbp&32, 1, 0) < 0) |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4254 return -1; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4255 cbp+=cbp; |
575 | 4256 } |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4257 goto end; |
0 | 4258 } |
4259 | |
4260 /* decode each block */ | |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4261 for (i = 0; i < 6; i++) { |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4262 if (mpeg4_decode_block(s, block[i], i, cbp&32, 0, 0) < 0) |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4263 return -1; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4264 cbp+=cbp; |
0 | 4265 } |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4266 end: |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4267 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4268 /* per-MB end of slice check */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4269 if(s->codec_id==CODEC_ID_MPEG4){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4270 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
|
4271 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
|
4272 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
|
4273 return SLICE_OK; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4274 return SLICE_END; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4275 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4276 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4277 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4278 return SLICE_OK; |
0 | 4279 } |
4280 | |
262 | 4281 static int h263_decode_motion(MpegEncContext * s, int pred, int f_code) |
0 | 4282 { |
656
e47fa3e3f2d5
statistics for forw & back p-MBs instead of just one counter for both
michaelni
parents:
654
diff
changeset
|
4283 int code, val, sign, shift, l; |
544 | 4284 code = get_vlc2(&s->gb, mv_vlc.table, MV_VLC_BITS, 2); |
0 | 4285 |
4286 if (code == 0) | |
4287 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
|
4288 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
|
4289 return 0xffff; |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
702
diff
changeset
|
4290 |
21 | 4291 sign = get_bits1(&s->gb); |
262 | 4292 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
|
4293 val = code; |
625ccacd1113
decode motion & modulo optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1254
diff
changeset
|
4294 if (shift) { |
625ccacd1113
decode motion & modulo optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1254
diff
changeset
|
4295 val = (val - 1) << shift; |
0 | 4296 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
|
4297 val++; |
625ccacd1113
decode motion & modulo optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1254
diff
changeset
|
4298 } |
0 | 4299 if (sign) |
4300 val = -val; | |
4301 val += pred; | |
475 | 4302 |
0 | 4303 /* modulo decoding */ |
4304 if (!s->h263_long_vectors) { | |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
702
diff
changeset
|
4305 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
|
4306 val = ((val + l)&(l*2-1)) - l; |
0 | 4307 } else { |
4308 /* horrible h263 long vector mode */ | |
4309 if (pred < -31 && val < -63) | |
4310 val += 64; | |
4311 if (pred > 32 && val > 63) | |
4312 val -= 64; | |
154
f914f710b8d0
- Fixed a bug on H.263 MV prediction for MB on GOBs limits.
pulento
parents:
144
diff
changeset
|
4313 |
0 | 4314 } |
4315 return val; | |
4316 } | |
4317 | |
78 | 4318 /* Decodes RVLC of H.263+ UMV */ |
4319 static int h263p_decode_umotion(MpegEncContext * s, int pred) | |
4320 { | |
4321 int code = 0, sign; | |
4322 | |
4323 if (get_bits1(&s->gb)) /* Motion difference = 0 */ | |
4324 return pred; | |
4325 | |
4326 code = 2 + get_bits1(&s->gb); | |
4327 | |
4328 while (get_bits1(&s->gb)) | |
4329 { | |
4330 code <<= 1; | |
4331 code += get_bits1(&s->gb); | |
4332 } | |
4333 sign = code & 1; | |
4334 code >>= 1; | |
4335 | |
4336 code = (sign) ? (pred - code) : (pred + code); | |
4337 #ifdef DEBUG | |
4338 fprintf(stderr,"H.263+ UMV Motion = %d\n", code); | |
4339 #endif | |
4340 return code; | |
4341 | |
4342 } | |
4343 | |
0 | 4344 static int h263_decode_block(MpegEncContext * s, DCTELEM * block, |
4345 int n, int coded) | |
4346 { | |
4347 int code, level, i, j, last, run; | |
4348 RLTable *rl = &rl_inter; | |
1064 | 4349 const uint8_t *scan_table; |
1637 | 4350 GetBitContext gb= s->gb; |
0 | 4351 |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
702
diff
changeset
|
4352 scan_table = s->intra_scantable.permutated; |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
4353 if (s->h263_aic && s->mb_intra) { |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
4354 rl = &rl_intra_aic; |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
4355 i = 0; |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
4356 if (s->ac_pred) { |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
4357 if (s->h263_aic_dir) |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
702
diff
changeset
|
4358 scan_table = s->intra_v_scantable.permutated; /* left */ |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
4359 else |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
702
diff
changeset
|
4360 scan_table = s->intra_h_scantable.permutated; /* top */ |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
4361 } |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
4362 } else if (s->mb_intra) { |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
4363 /* DC coef */ |
1641 | 4364 if(s->codec_id == CODEC_ID_RV10){ |
1090 | 4365 if (s->rv10_version == 3 && s->pict_type == I_TYPE) { |
0 | 4366 int component, diff; |
4367 component = (n <= 3 ? 0 : n - 4 + 1); | |
4368 level = s->last_dc[component]; | |
4369 if (s->rv10_first_dc_coded[component]) { | |
4370 diff = rv_decode_dc(s, n); | |
4371 if (diff == 0xffff) | |
4372 return -1; | |
4373 level += diff; | |
4374 level = level & 0xff; /* handle wrap round */ | |
4375 s->last_dc[component] = level; | |
4376 } else { | |
4377 s->rv10_first_dc_coded[component] = 1; | |
4378 } | |
1090 | 4379 } else { |
4380 level = get_bits(&s->gb, 8); | |
4381 } | |
4382 }else{ | |
0 | 4383 level = get_bits(&s->gb, 8); |
1089 | 4384 if((level&0x7F) == 0){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
4385 av_log(s->avctx, AV_LOG_ERROR, "illegal dc %d at %d %d\n", level, s->mb_x, s->mb_y); |
1089 | 4386 return -1; |
4387 } | |
0 | 4388 if (level == 255) |
4389 level = 128; | |
4390 } | |
4391 block[0] = level; | |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
4392 i = 1; |
0 | 4393 } else { |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
4394 i = 0; |
0 | 4395 } |
4396 if (!coded) { | |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
4397 if (s->mb_intra && s->h263_aic) |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
4398 goto not_coded; |
0 | 4399 s->block_last_index[n] = i - 1; |
4400 return 0; | |
4401 } | |
1637 | 4402 retry: |
0 | 4403 for(;;) { |
544 | 4404 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
|
4405 if (code < 0){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
4406 av_log(s->avctx, AV_LOG_ERROR, "illegal ac vlc code at %dx%d\n", s->mb_x, s->mb_y); |
0 | 4407 return -1; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4408 } |
0 | 4409 if (code == rl->n) { |
4410 /* escape */ | |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
4411 if (s->h263_flv > 1) { |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
4412 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
|
4413 last = get_bits1(&s->gb); |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
4414 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
|
4415 if(is11){ |
1356 | 4416 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
|
4417 } else { |
1356 | 4418 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
|
4419 } |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
4420 } else { |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
4421 last = get_bits1(&s->gb); |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
4422 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
|
4423 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
|
4424 if(level == -128){ |
1641 | 4425 if (s->codec_id == CODEC_ID_RV10) { |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
4426 /* XXX: should patch encoder too */ |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
4427 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
|
4428 }else{ |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
4429 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
|
4430 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
|
4431 } |
1089 | 4432 } |
0 | 4433 } |
4434 } else { | |
4435 run = rl->table_run[code]; | |
4436 level = rl->table_level[code]; | |
4437 last = code >= rl->last; | |
21 | 4438 if (get_bits1(&s->gb)) |
0 | 4439 level = -level; |
4440 } | |
4441 i += run; | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4442 if (i >= 64){ |
1637 | 4443 if(s->alt_inter_vlc && rl == &rl_inter && !s->mb_intra){ |
4444 //looks like a hack but no, its the way its supposed to work ... | |
4445 rl = &rl_intra_aic; | |
4446 i = 0; | |
4447 s->gb= gb; | |
4448 memset(block, 0, sizeof(DCTELEM)*64); | |
4449 goto retry; | |
4450 } | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
4451 av_log(s->avctx, AV_LOG_ERROR, "run overflow at %dx%d\n", s->mb_x, s->mb_y); |
0 | 4452 return -1; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4453 } |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
4454 j = scan_table[i]; |
0 | 4455 block[j] = level; |
4456 if (last) | |
4457 break; | |
4458 i++; | |
4459 } | |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
4460 not_coded: |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
4461 if (s->mb_intra && s->h263_aic) { |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
4462 h263_pred_acdc(s, block, n); |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
4463 i = 63; |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
4464 } |
0 | 4465 s->block_last_index[n] = i; |
4466 return 0; | |
4467 } | |
4468 | |
1034 | 4469 /** |
4470 * decodes the dc value. | |
4471 * @param n block index (0-3 are luma, 4-5 are chroma) | |
4472 * @param dir_ptr the prediction direction will be stored here | |
4473 * @return the quantized dc | |
4474 */ | |
453 | 4475 static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr) |
0 | 4476 { |
4477 int level, pred, code; | |
1064 | 4478 uint16_t *dc_val; |
0 | 4479 |
4480 if (n < 4) | |
544 | 4481 code = get_vlc2(&s->gb, dc_lum.table, DC_VLC_BITS, 1); |
0 | 4482 else |
544 | 4483 code = get_vlc2(&s->gb, dc_chrom.table, DC_VLC_BITS, 1); |
453 | 4484 if (code < 0 || code > 9 /* && s->nbit<9 */){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
4485 av_log(s->avctx, AV_LOG_ERROR, "illegal dc vlc\n"); |
0 | 4486 return -1; |
453 | 4487 } |
0 | 4488 if (code == 0) { |
4489 level = 0; | |
4490 } 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
|
4491 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
|
4492 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
|
4493 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
|
4494 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
|
4495 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
|
4496 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
|
4497 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
|
4498 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
|
4499 } |
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
|
4500 }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
|
4501 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
|
4502 } |
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
|
4503 |
453 | 4504 if (code > 8){ |
4505 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
|
4506 if(s->error_resilience>=2){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
4507 av_log(s->avctx, AV_LOG_ERROR, "dc marker bit missing\n"); |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4508 return -1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4509 } |
453 | 4510 } |
4511 } | |
0 | 4512 } |
498 | 4513 pred = ff_mpeg4_pred_dc(s, n, &dc_val, dir_ptr); |
0 | 4514 level += pred; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4515 if (level < 0){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4516 if(s->error_resilience>=3){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
4517 av_log(s->avctx, AV_LOG_ERROR, "dc<0 at %dx%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
|
4518 return -1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4519 } |
0 | 4520 level = 0; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4521 } |
0 | 4522 if (n < 4) { |
4523 *dc_val = level * s->y_dc_scale; | |
4524 } else { | |
4525 *dc_val = level * s->c_dc_scale; | |
4526 } | |
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
|
4527 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
|
4528 *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
|
4529 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4530 if(s->error_resilience>=3){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4531 if(*dc_val > 2048 + s->y_dc_scale + s->c_dc_scale){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
4532 av_log(s->avctx, AV_LOG_ERROR, "dc overflow at %dx%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
|
4533 return -1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4534 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4535 } |
0 | 4536 return level; |
4537 } | |
4538 | |
453 | 4539 /** |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4540 * decodes a block. |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4541 * @return <0 if an error occured |
453 | 4542 */ |
4543 static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block, | |
1132 | 4544 int n, int coded, int intra, int rvlc) |
0 | 4545 { |
549 | 4546 int level, i, last, run; |
0 | 4547 int dc_pred_dir; |
575 | 4548 RLTable * rl; |
4549 RL_VLC_ELEM * rl_vlc; | |
1064 | 4550 const uint8_t * scan_table; |
549 | 4551 int qmul, qadd; |
0 | 4552 |
1132 | 4553 //Note intra & rvlc should be optimized away if this is inlined |
4554 | |
575 | 4555 if(intra) { |
1520 | 4556 if(s->qscale < s->intra_dc_threshold){ |
0 | 4557 /* DC coef */ |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4558 if(s->partitioned_frame){ |
453 | 4559 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
|
4560 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
|
4561 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
|
4562 dc_pred_dir= (s->pred_dir_table[s->mb_x + s->mb_y*s->mb_stride]<<n)&32; |
453 | 4563 }else{ |
4564 level = mpeg4_decode_dc(s, n, &dc_pred_dir); | |
4565 if (level < 0) | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4566 return -1; |
453 | 4567 } |
0 | 4568 block[0] = level; |
549 | 4569 i = 0; |
1520 | 4570 }else{ |
4571 i = -1; | |
4572 } | |
0 | 4573 if (!coded) |
4574 goto not_coded; | |
1132 | 4575 |
4576 if(rvlc){ | |
4577 rl = &rvlc_rl_intra; | |
4578 rl_vlc = rvlc_rl_intra.rl_vlc[0]; | |
4579 }else{ | |
4580 rl = &rl_intra; | |
4581 rl_vlc = rl_intra.rl_vlc[0]; | |
4582 } | |
718 | 4583 if (s->ac_pred) { |
0 | 4584 if (dc_pred_dir == 0) |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
702
diff
changeset
|
4585 scan_table = s->intra_v_scantable.permutated; /* left */ |
0 | 4586 else |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
702
diff
changeset
|
4587 scan_table = s->intra_h_scantable.permutated; /* top */ |
0 | 4588 } else { |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
702
diff
changeset
|
4589 scan_table = s->intra_scantable.permutated; |
0 | 4590 } |
549 | 4591 qmul=1; |
4592 qadd=0; | |
0 | 4593 } else { |
549 | 4594 i = -1; |
0 | 4595 if (!coded) { |
549 | 4596 s->block_last_index[n] = i; |
0 | 4597 return 0; |
4598 } | |
1132 | 4599 if(rvlc) rl = &rvlc_rl_inter; |
4600 else rl = &rl_inter; | |
661 | 4601 |
718 | 4602 scan_table = s->intra_scantable.permutated; |
661 | 4603 |
591 | 4604 if(s->mpeg_quant){ |
4605 qmul=1; | |
4606 qadd=0; | |
1132 | 4607 if(rvlc){ |
4608 rl_vlc = rvlc_rl_inter.rl_vlc[0]; | |
4609 }else{ | |
4610 rl_vlc = rl_inter.rl_vlc[0]; | |
4611 } | |
591 | 4612 }else{ |
4613 qmul = s->qscale << 1; | |
4614 qadd = (s->qscale - 1) | 1; | |
1132 | 4615 if(rvlc){ |
4616 rl_vlc = rvlc_rl_inter.rl_vlc[s->qscale]; | |
4617 }else{ | |
4618 rl_vlc = rl_inter.rl_vlc[s->qscale]; | |
4619 } | |
591 | 4620 } |
0 | 4621 } |
549 | 4622 { |
4623 OPEN_READER(re, &s->gb); | |
0 | 4624 for(;;) { |
549 | 4625 UPDATE_CACHE(re, &s->gb); |
4626 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2); | |
4627 if (level==0) { | |
1132 | 4628 /* escape */ |
4629 if(rvlc){ | |
4630 if(SHOW_UBITS(re, &s->gb, 1)==0){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
4631 av_log(s->avctx, AV_LOG_ERROR, "1. marker bit missing in rvlc esc\n"); |
1132 | 4632 return -1; |
4633 }; SKIP_CACHE(re, &s->gb, 1); | |
4634 | |
4635 last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1); | |
4636 run= SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6); | |
4637 SKIP_COUNTER(re, &s->gb, 1+1+6); | |
4638 UPDATE_CACHE(re, &s->gb); | |
4639 | |
4640 if(SHOW_UBITS(re, &s->gb, 1)==0){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
4641 av_log(s->avctx, AV_LOG_ERROR, "2. marker bit missing in rvlc esc\n"); |
1132 | 4642 return -1; |
4643 }; SKIP_CACHE(re, &s->gb, 1); | |
4644 | |
4645 level= SHOW_UBITS(re, &s->gb, 11); SKIP_CACHE(re, &s->gb, 11); | |
4646 | |
4647 if(SHOW_UBITS(re, &s->gb, 5)!=0x10){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
4648 av_log(s->avctx, AV_LOG_ERROR, "reverse esc missing\n"); |
1132 | 4649 return -1; |
4650 }; SKIP_CACHE(re, &s->gb, 5); | |
4651 | |
4652 level= level * qmul + qadd; | |
4653 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); LAST_SKIP_CACHE(re, &s->gb, 1); | |
4654 SKIP_COUNTER(re, &s->gb, 1+11+5+1); | |
4655 | |
4656 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
|
4657 if(last) i+=192; |
1132 | 4658 }else{ |
549 | 4659 int cache; |
4660 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
|
4661 |
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
|
4662 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
|
4663 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
|
4664 |
549 | 4665 if (cache&0x80000000) { |
4666 if (cache&0x40000000) { | |
0 | 4667 /* third escape */ |
549 | 4668 SKIP_CACHE(re, &s->gb, 2); |
4669 last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1); | |
4670 run= SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6); | |
4671 SKIP_COUNTER(re, &s->gb, 2+1+6); | |
4672 UPDATE_CACHE(re, &s->gb); | |
4673 | |
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
|
4674 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
|
4675 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
|
4676 }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
|
4677 if(SHOW_UBITS(re, &s->gb, 1)==0){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
4678 av_log(s->avctx, AV_LOG_ERROR, "1. marker bit missing in 3. esc\n"); |
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
|
4679 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
|
4680 }; 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
|
4681 |
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
|
4682 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
|
4683 |
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
|
4684 if(SHOW_UBITS(re, &s->gb, 1)==0){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
4685 av_log(s->avctx, AV_LOG_ERROR, "2. marker bit missing in 3. esc\n"); |
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
|
4686 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
|
4687 }; 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
|
4688 |
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
|
4689 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
|
4690 } |
549 | 4691 |
597 | 4692 if(level*s->qscale>1024 || level*s->qscale<-1024){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
4693 av_log(s->avctx, AV_LOG_ERROR, "|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
|
4694 return -1; |
453 | 4695 } |
1525
39efe24058ad
dont check if the ac esc 3 could have been stored as vlc as this detects only very few errors allthough it detects several buggy encoders
michael
parents:
1522
diff
changeset
|
4696 #if 0 |
39efe24058ad
dont check if the ac esc 3 could have been stored as vlc as this detects only very few errors allthough it detects several buggy encoders
michael
parents:
1522
diff
changeset
|
4697 if(s->error_resilience >= FF_ER_COMPLIANT){ |
453 | 4698 const int abs_level= ABS(level); |
1525
39efe24058ad
dont check if the ac esc 3 could have been stored as vlc as this detects only very few errors allthough it detects several buggy encoders
michael
parents:
1522
diff
changeset
|
4699 if(abs_level<=MAX_LEVEL && run<=MAX_RUN){ |
498 | 4700 const int run1= run - rl->max_run[last][abs_level] - 1; |
453 | 4701 if(abs_level <= rl->max_level[last][run]){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
4702 av_log(s->avctx, AV_LOG_ERROR, "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
|
4703 return -1; |
453 | 4704 } |
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
|
4705 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
|
4706 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
|
4707 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
|
4708 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
|
4709 } |
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
|
4710 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
|
4711 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
|
4712 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
|
4713 } |
453 | 4714 } |
4715 } | |
4716 } | |
4717 #endif | |
549 | 4718 if (level>0) level= level * qmul + qadd; |
4719 else level= level * qmul - qadd; | |
4720 | |
4721 i+= run + 1; | |
4722 if(last) i+=192; | |
0 | 4723 } else { |
4724 /* second escape */ | |
549 | 4725 #if MIN_CACHE_BITS < 20 |
4726 LAST_SKIP_BITS(re, &s->gb, 2); | |
4727 UPDATE_CACHE(re, &s->gb); | |
4728 #else | |
4729 SKIP_BITS(re, &s->gb, 2); | |
4730 #endif | |
4731 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2); | |
4732 i+= run + rl->max_run[run>>7][level/qmul] +1; //FIXME opt indexing | |
4733 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); | |
4734 LAST_SKIP_BITS(re, &s->gb, 1); | |
0 | 4735 } |
4736 } else { | |
4737 /* first escape */ | |
549 | 4738 #if MIN_CACHE_BITS < 19 |
4739 LAST_SKIP_BITS(re, &s->gb, 1); | |
4740 UPDATE_CACHE(re, &s->gb); | |
4741 #else | |
4742 SKIP_BITS(re, &s->gb, 1); | |
4743 #endif | |
4744 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2); | |
4745 i+= run; | |
4746 level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//FIXME opt indexing | |
4747 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); | |
4748 LAST_SKIP_BITS(re, &s->gb, 1); | |
0 | 4749 } |
1132 | 4750 } |
0 | 4751 } else { |
549 | 4752 i+= run; |
4753 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); | |
4754 LAST_SKIP_BITS(re, &s->gb, 1); | |
0 | 4755 } |
549 | 4756 if (i > 62){ |
4757 i-= 192; | |
4758 if(i&(~63)){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
4759 av_log(s->avctx, AV_LOG_ERROR, "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
|
4760 return -1; |
549 | 4761 } |
4762 | |
4763 block[scan_table[i]] = level; | |
0 | 4764 break; |
549 | 4765 } |
4766 | |
4767 block[scan_table[i]] = level; | |
0 | 4768 } |
549 | 4769 CLOSE_READER(re, &s->gb); |
4770 } | |
0 | 4771 not_coded: |
1520 | 4772 if (intra) { |
4773 if(s->qscale >= s->intra_dc_threshold){ | |
4774 uint16_t *dc_val; | |
4775 block[0] += ff_mpeg4_pred_dc(s, n, &dc_val, &dc_pred_dir); | |
4776 if (n < 4) { | |
4777 *dc_val = block[0] * s->y_dc_scale; | |
4778 } else { | |
4779 *dc_val = block[0] * s->c_dc_scale; | |
4780 } | |
4781 | |
4782 if(i == -1) i=0; | |
4783 } | |
4784 | |
0 | 4785 mpeg4_pred_ac(s, block, n, dc_pred_dir); |
4786 if (s->ac_pred) { | |
549 | 4787 i = 63; /* XXX: not optimal */ |
0 | 4788 } |
4789 } | |
549 | 4790 s->block_last_index[n] = i; |
0 | 4791 return 0; |
4792 } | |
4793 | |
4794 /* most is hardcoded. should extend to handle all h263 streams */ | |
4795 int h263_decode_picture_header(MpegEncContext *s) | |
4796 { | |
1278
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4797 int format, width, height, i; |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4798 uint32_t startcode; |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4799 |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4800 align_get_bits(&s->gb); |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4801 |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4802 startcode= get_bits(&s->gb, 22-8); |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4803 |
1393 | 4804 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
|
4805 startcode = ((startcode << 8) | get_bits(&s->gb, 8)) & 0x003FFFFF; |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4806 |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4807 if(startcode == 0x20) |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4808 break; |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4809 } |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4810 |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4811 if (startcode != 0x20) { |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
4812 av_log(s->avctx, AV_LOG_ERROR, "Bad picture start code\n"); |
0 | 4813 return -1; |
355 | 4814 } |
4815 /* temporal reference */ | |
231 | 4816 s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */ |
355 | 4817 |
4818 /* PTYPE starts here */ | |
4819 if (get_bits1(&s->gb) != 1) { | |
4820 /* marker */ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
4821 av_log(s->avctx, AV_LOG_ERROR, "Bad marker\n"); |
355 | 4822 return -1; |
4823 } | |
4824 if (get_bits1(&s->gb) != 0) { | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
4825 av_log(s->avctx, AV_LOG_ERROR, "Bad H263 id\n"); |
0 | 4826 return -1; /* h263 id */ |
355 | 4827 } |
21 | 4828 skip_bits1(&s->gb); /* split screen off */ |
4829 skip_bits1(&s->gb); /* camera off */ | |
4830 skip_bits1(&s->gb); /* freeze picture release off */ | |
0 | 4831 |
4832 format = get_bits(&s->gb, 3); | |
355 | 4833 /* |
4834 0 forbidden | |
4835 1 sub-QCIF | |
4836 10 QCIF | |
4837 7 extended PTYPE (PLUSPTYPE) | |
4838 */ | |
0 | 4839 |
161 | 4840 if (format != 7 && format != 6) { |
0 | 4841 s->h263_plus = 0; |
4842 /* H.263v1 */ | |
4843 width = h263_format[format][0]; | |
4844 height = h263_format[format][1]; | |
4845 if (!width) | |
4846 return -1; | |
161 | 4847 |
21 | 4848 s->pict_type = I_TYPE + get_bits1(&s->gb); |
0 | 4849 |
1633 | 4850 s->h263_long_vectors = get_bits1(&s->gb); |
0 | 4851 |
355 | 4852 if (get_bits1(&s->gb) != 0) { |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
4853 av_log(s->avctx, AV_LOG_ERROR, "H263 SAC not supported\n"); |
0 | 4854 return -1; /* SAC: off */ |
355 | 4855 } |
1633 | 4856 s->obmc= get_bits1(&s->gb); /* Advanced prediction mode */ |
4857 s->unrestricted_mv = s->h263_long_vectors || s->obmc; | |
161 | 4858 |
355 | 4859 if (get_bits1(&s->gb) != 0) { |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
4860 av_log(s->avctx, AV_LOG_ERROR, "H263 PB frame not supported\n"); |
0 | 4861 return -1; /* not PB frame */ |
355 | 4862 } |
1644 | 4863 s->chroma_qscale= s->qscale = get_bits(&s->gb, 5); |
21 | 4864 skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */ |
1393 | 4865 |
4866 s->width = width; | |
4867 s->height = height; | |
0 | 4868 } else { |
161 | 4869 int ufep; |
4870 | |
0 | 4871 /* H.263v2 */ |
161 | 4872 s->h263_plus = 1; |
4873 ufep = get_bits(&s->gb, 3); /* Update Full Extended PTYPE */ | |
355 | 4874 |
4875 /* ufep other than 0 and 1 are reserved */ | |
161 | 4876 if (ufep == 1) { |
4877 /* OPPTYPE */ | |
4878 format = get_bits(&s->gb, 3); | |
355 | 4879 dprintf("ufep=1, format: %d\n", format); |
161 | 4880 skip_bits(&s->gb,1); /* Custom PCF */ |
1089 | 4881 s->umvplus = get_bits(&s->gb, 1); /* Unrestricted Motion Vector */ |
1644 | 4882 if (get_bits1(&s->gb) != 0) { |
4883 av_log(s->avctx, AV_LOG_ERROR, "Syntax-based Arithmetic Coding (SAC) not supported\n"); | |
4884 } | |
1633 | 4885 s->obmc= get_bits1(&s->gb); /* Advanced prediction mode */ |
4886 s->h263_aic = get_bits1(&s->gb); /* Advanced Intra Coding (AIC) */ | |
1644 | 4887 s->loop_filter= get_bits1(&s->gb); |
4888 s->unrestricted_mv = s->umvplus || s->obmc || s->loop_filter; | |
4889 | |
1661 | 4890 s->h263_slice_structured= get_bits1(&s->gb); |
1278
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4891 if (get_bits1(&s->gb) != 0) { |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
4892 av_log(s->avctx, AV_LOG_ERROR, "Reference Picture Selection not supported\n"); |
1278
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4893 } |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4894 if (get_bits1(&s->gb) != 0) { |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
4895 av_log(s->avctx, AV_LOG_ERROR, "Independent Segment Decoding not supported\n"); |
1278
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4896 } |
1637 | 4897 s->alt_inter_vlc= get_bits1(&s->gb); |
1639 | 4898 s->modified_quant= get_bits1(&s->gb); |
1644 | 4899 if(s->modified_quant) |
4900 s->chroma_qscale_table= ff_h263_chroma_qscale_table; | |
1278
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4901 |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
4902 skip_bits(&s->gb, 1); /* Prevent start code emulation */ |
355 | 4903 |
161 | 4904 skip_bits(&s->gb, 3); /* Reserved */ |
355 | 4905 } else if (ufep != 0) { |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
4906 av_log(s->avctx, AV_LOG_ERROR, "Bad UFEP type (%d)\n", ufep); |
0 | 4907 return -1; |
355 | 4908 } |
161 | 4909 |
78 | 4910 /* MPPTYPE */ |
1655 | 4911 s->pict_type = get_bits(&s->gb, 3); |
4912 switch(s->pict_type){ | |
4913 case 0: s->pict_type= I_TYPE;break; | |
4914 case 1: s->pict_type= P_TYPE;break; | |
4915 case 3: s->pict_type= B_TYPE;break; | |
4916 case 7: s->pict_type= I_TYPE;break; //ZYGO | |
4917 default: | |
0 | 4918 return -1; |
1655 | 4919 } |
250
3449316664b5
- Bug fix on RTYPE (rounding type) not being honoured by H.263+ decoder.
pulento
parents:
249
diff
changeset
|
4920 skip_bits(&s->gb, 2); |
3449316664b5
- Bug fix on RTYPE (rounding type) not being honoured by H.263+ decoder.
pulento
parents:
249
diff
changeset
|
4921 s->no_rounding = get_bits1(&s->gb); |
3449316664b5
- Bug fix on RTYPE (rounding type) not being honoured by H.263+ decoder.
pulento
parents:
249
diff
changeset
|
4922 skip_bits(&s->gb, 4); |
78 | 4923 |
4924 /* Get the picture dimensions */ | |
161 | 4925 if (ufep) { |
4926 if (format == 6) { | |
4927 /* Custom Picture Format (CPFMT) */ | |
355 | 4928 s->aspect_ratio_info = get_bits(&s->gb, 4); |
4929 dprintf("aspect: %d\n", s->aspect_ratio_info); | |
4930 /* aspect ratios: | |
4931 0 - forbidden | |
4932 1 - 1:1 | |
4933 2 - 12:11 (CIF 4:3) | |
4934 3 - 10:11 (525-type 4:3) | |
4935 4 - 16:11 (CIF 16:9) | |
4936 5 - 40:33 (525-type 16:9) | |
4937 6-14 - reserved | |
4938 */ | |
161 | 4939 width = (get_bits(&s->gb, 9) + 1) * 4; |
4940 skip_bits1(&s->gb); | |
4941 height = get_bits(&s->gb, 9) * 4; | |
355 | 4942 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
|
4943 if (s->aspect_ratio_info == FF_ASPECT_EXTENDED) { |
355 | 4944 /* aspected dimensions */ |
1548 | 4945 s->avctx->sample_aspect_ratio.num= get_bits(&s->gb, 8); |
4946 s->avctx->sample_aspect_ratio.den= get_bits(&s->gb, 8); | |
887 | 4947 }else{ |
1548 | 4948 s->avctx->sample_aspect_ratio= pixel_aspect[s->aspect_ratio_info]; |
355 | 4949 } |
4950 } else { | |
161 | 4951 width = h263_format[format][0]; |
4952 height = h263_format[format][1]; | |
4953 } | |
4954 if ((width == 0) || (height == 0)) | |
4955 return -1; | |
4956 s->width = width; | |
4957 s->height = height; | |
1089 | 4958 if (s->umvplus) { |
4959 if(get_bits1(&s->gb)==0) /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */ | |
4960 skip_bits1(&s->gb); | |
161 | 4961 } |
1661 | 4962 if(s->h263_slice_structured){ |
4963 if (get_bits1(&s->gb) != 0) { | |
4964 av_log(s->avctx, AV_LOG_ERROR, "rectangular slices not supported\n"); | |
4965 } | |
4966 if (get_bits1(&s->gb) != 0) { | |
4967 av_log(s->avctx, AV_LOG_ERROR, "unordered slices not supported\n"); | |
4968 } | |
4969 } | |
78 | 4970 } |
4971 | |
0 | 4972 s->qscale = get_bits(&s->gb, 5); |
4973 } | |
1670 | 4974 |
0 | 4975 /* PEI */ |
21 | 4976 while (get_bits1(&s->gb) != 0) { |
4977 skip_bits(&s->gb, 8); | |
0 | 4978 } |
1670 | 4979 |
4980 if(s->h263_slice_structured){ | |
4981 if (get_bits1(&s->gb) != 1) { | |
4982 av_log(s->avctx, AV_LOG_ERROR, "SEPB1 marker missing\n"); | |
4983 return -1; | |
4984 } | |
4985 | |
4986 ff_h263_decode_mba(s); | |
4987 | |
4988 if (get_bits1(&s->gb) != 1) { | |
4989 av_log(s->avctx, AV_LOG_ERROR, "SEPB2 marker missing\n"); | |
4990 return -1; | |
4991 } | |
4992 } | |
0 | 4993 s->f_code = 1; |
498 | 4994 |
4995 if(s->h263_aic){ | |
4996 s->y_dc_scale_table= | |
1639 | 4997 s->c_dc_scale_table= ff_aic_dc_scale_table; |
498 | 4998 }else{ |
4999 s->y_dc_scale_table= | |
5000 s->c_dc_scale_table= ff_mpeg1_dc_scale_table; | |
5001 } | |
5002 | |
1278
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
5003 if(s->avctx->debug&FF_DEBUG_PICT_INFO){ |
1661 | 5004 av_log(s->avctx, AV_LOG_DEBUG, "qp:%d %c size:%d rnd:%d%s%s%s%s%s%s%s%s%s\n", |
1278
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
5005 s->qscale, av_get_pict_type_char(s->pict_type), |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
5006 s->gb.size_in_bits, 1-s->no_rounding, |
1633 | 5007 s->obmc ? " AP" : "", |
5008 s->umvplus ? " UMV" : "", | |
5009 s->h263_long_vectors ? " LONG" : "", | |
5010 s->h263_plus ? " +" : "", | |
1637 | 5011 s->h263_aic ? " AIC" : "", |
1639 | 5012 s->alt_inter_vlc ? " AIV" : "", |
1644 | 5013 s->modified_quant ? " MQ" : "", |
1661 | 5014 s->loop_filter ? " LOOP" : "", |
5015 s->h263_slice_structured ? " SS" : "" | |
1278
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
5016 ); |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
5017 } |
1584
3615999a7284
dumping funny numbers from first zygo i frame header
michael
parents:
1583
diff
changeset
|
5018 #if 1 |
3615999a7284
dumping funny numbers from first zygo i frame header
michael
parents:
1583
diff
changeset
|
5019 if (s->pict_type == I_TYPE && s->avctx->codec_tag == ff_get_fourcc("ZYGO")){ |
3615999a7284
dumping funny numbers from first zygo i frame header
michael
parents:
1583
diff
changeset
|
5020 int i,j; |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5021 for(i=0; i<85; i++) av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb)); |
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5022 av_log(s->avctx, AV_LOG_DEBUG, "\n"); |
1584
3615999a7284
dumping funny numbers from first zygo i frame header
michael
parents:
1583
diff
changeset
|
5023 for(i=0; i<13; i++){ |
3615999a7284
dumping funny numbers from first zygo i frame header
michael
parents:
1583
diff
changeset
|
5024 for(j=0; j<3; j++){ |
3615999a7284
dumping funny numbers from first zygo i frame header
michael
parents:
1583
diff
changeset
|
5025 int v= get_bits(&s->gb, 8); |
3615999a7284
dumping funny numbers from first zygo i frame header
michael
parents:
1583
diff
changeset
|
5026 v |= get_sbits(&s->gb, 8)<<8; |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5027 av_log(s->avctx, AV_LOG_DEBUG, " %5d", v); |
1584
3615999a7284
dumping funny numbers from first zygo i frame header
michael
parents:
1583
diff
changeset
|
5028 } |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5029 av_log(s->avctx, AV_LOG_DEBUG, "\n"); |
1584
3615999a7284
dumping funny numbers from first zygo i frame header
michael
parents:
1583
diff
changeset
|
5030 } |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5031 for(i=0; i<50; i++) av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb)); |
1584
3615999a7284
dumping funny numbers from first zygo i frame header
michael
parents:
1583
diff
changeset
|
5032 } |
3615999a7284
dumping funny numbers from first zygo i frame header
michael
parents:
1583
diff
changeset
|
5033 #endif |
3615999a7284
dumping funny numbers from first zygo i frame header
michael
parents:
1583
diff
changeset
|
5034 |
0 | 5035 return 0; |
5036 } | |
5037 | |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5038 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
|
5039 { |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5040 int i; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5041 int a= 2<<s->sprite_warping_accuracy; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5042 int rho= 3-s->sprite_warping_accuracy; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5043 int r=16/a; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5044 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
|
5045 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
|
5046 int sprite_ref[4][2]; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5047 int virtual_ref[2][2]; |
753 | 5048 int w2, h2, w3, h3; |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5049 int alpha=0, beta=0; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5050 int w= s->width; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5051 int h= s->height; |
753 | 5052 int min_ab; |
5053 | |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5054 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
|
5055 int length; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5056 int x=0, y=0; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5057 |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5058 length= get_vlc(&s->gb, &sprite_trajectory); |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5059 if(length){ |
1254
604661d34c68
bitstream reader optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1237
diff
changeset
|
5060 x= get_xbits(&s->gb, length); |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5061 } |
255 | 5062 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
|
5063 |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5064 length= get_vlc(&s->gb, &sprite_trajectory); |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5065 if(length){ |
1254
604661d34c68
bitstream reader optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1237
diff
changeset
|
5066 y=get_xbits(&s->gb, length); |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5067 } |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5068 skip_bits1(&s->gb); /* marker bit */ |
255 | 5069 //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
|
5070 d[i][0]= x; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5071 d[i][1]= y; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5072 } |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5073 |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5074 while((1<<alpha)<w) alpha++; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5075 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
|
5076 w2= 1<<alpha; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5077 h2= 1<<beta; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5078 |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5079 // Note, the 4th point isnt used for GMC |
262 | 5080 if(s->divx_version==500 && s->divx_build==413){ |
5081 sprite_ref[0][0]= a*vop_ref[0][0] + d[0][0]; | |
5082 sprite_ref[0][1]= a*vop_ref[0][1] + d[0][1]; | |
5083 sprite_ref[1][0]= a*vop_ref[1][0] + d[0][0] + d[1][0]; | |
5084 sprite_ref[1][1]= a*vop_ref[1][1] + d[0][1] + d[1][1]; | |
5085 sprite_ref[2][0]= a*vop_ref[2][0] + d[0][0] + d[2][0]; | |
5086 sprite_ref[2][1]= a*vop_ref[2][1] + d[0][1] + d[2][1]; | |
5087 } else { | |
5088 sprite_ref[0][0]= (a>>1)*(2*vop_ref[0][0] + d[0][0]); | |
5089 sprite_ref[0][1]= (a>>1)*(2*vop_ref[0][1] + d[0][1]); | |
5090 sprite_ref[1][0]= (a>>1)*(2*vop_ref[1][0] + d[0][0] + d[1][0]); | |
5091 sprite_ref[1][1]= (a>>1)*(2*vop_ref[1][1] + d[0][1] + d[1][1]); | |
5092 sprite_ref[2][0]= (a>>1)*(2*vop_ref[2][0] + d[0][0] + d[2][0]); | |
5093 sprite_ref[2][1]= (a>>1)*(2*vop_ref[2][1] + d[0][1] + d[2][1]); | |
5094 } | |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5095 /* 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
|
5096 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
|
5097 |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5098 // 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
|
5099 // 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
|
5100 // 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
|
5101 // 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
|
5102 virtual_ref[0][0]= 16*(vop_ref[0][0] + w2) |
359 | 5103 + 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
|
5104 virtual_ref[0][1]= 16*vop_ref[0][1] |
359 | 5105 + 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
|
5106 virtual_ref[1][0]= 16*vop_ref[0][0] |
359 | 5107 + 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
|
5108 virtual_ref[1][1]= 16*(vop_ref[0][1] + h2) |
359 | 5109 + 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 | 5110 |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5111 switch(s->num_sprite_warping_points) |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5112 { |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5113 case 0: |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5114 s->sprite_offset[0][0]= 0; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5115 s->sprite_offset[0][1]= 0; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5116 s->sprite_offset[1][0]= 0; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5117 s->sprite_offset[1][1]= 0; |
753 | 5118 s->sprite_delta[0][0]= a; |
5119 s->sprite_delta[0][1]= 0; | |
5120 s->sprite_delta[1][0]= 0; | |
5121 s->sprite_delta[1][1]= a; | |
5122 s->sprite_shift[0]= 0; | |
5123 s->sprite_shift[1]= 0; | |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5124 break; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5125 case 1: //GMC only |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5126 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
|
5127 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
|
5128 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
|
5129 s->sprite_offset[1][1]= ((sprite_ref[0][1]>>1)|(sprite_ref[0][1]&1)) - a*(vop_ref[0][1]/2); |
753 | 5130 s->sprite_delta[0][0]= a; |
5131 s->sprite_delta[0][1]= 0; | |
5132 s->sprite_delta[1][0]= 0; | |
5133 s->sprite_delta[1][1]= a; | |
5134 s->sprite_shift[0]= 0; | |
5135 s->sprite_shift[1]= 0; | |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5136 break; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5137 case 2: |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5138 s->sprite_offset[0][0]= (sprite_ref[0][0]<<(alpha+rho)) |
753 | 5139 + (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][0]) |
5140 + ( r*sprite_ref[0][1] - virtual_ref[0][1])*(-vop_ref[0][1]) | |
5141 + (1<<(alpha+rho-1)); | |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5142 s->sprite_offset[0][1]= (sprite_ref[0][1]<<(alpha+rho)) |
753 | 5143 + (-r*sprite_ref[0][1] + virtual_ref[0][1])*(-vop_ref[0][0]) |
5144 + (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][1]) | |
5145 + (1<<(alpha+rho-1)); | |
5146 s->sprite_offset[1][0]= ( (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][0] + 1) | |
5147 +( r*sprite_ref[0][1] - virtual_ref[0][1])*(-2*vop_ref[0][1] + 1) | |
5148 +2*w2*r*sprite_ref[0][0] | |
5149 - 16*w2 | |
5150 + (1<<(alpha+rho+1))); | |
5151 s->sprite_offset[1][1]= ( (-r*sprite_ref[0][1] + virtual_ref[0][1])*(-2*vop_ref[0][0] + 1) | |
5152 +(-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][1] + 1) | |
5153 +2*w2*r*sprite_ref[0][1] | |
5154 - 16*w2 | |
5155 + (1<<(alpha+rho+1))); | |
5156 s->sprite_delta[0][0]= (-r*sprite_ref[0][0] + virtual_ref[0][0]); | |
5157 s->sprite_delta[0][1]= (+r*sprite_ref[0][1] - virtual_ref[0][1]); | |
5158 s->sprite_delta[1][0]= (-r*sprite_ref[0][1] + virtual_ref[0][1]); | |
5159 s->sprite_delta[1][1]= (-r*sprite_ref[0][0] + virtual_ref[0][0]); | |
5160 | |
5161 s->sprite_shift[0]= alpha+rho; | |
5162 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
|
5163 break; |
753 | 5164 case 3: |
847 | 5165 min_ab= FFMIN(alpha, beta); |
753 | 5166 w3= w2>>min_ab; |
5167 h3= h2>>min_ab; | |
5168 s->sprite_offset[0][0]= (sprite_ref[0][0]<<(alpha+beta+rho-min_ab)) | |
5169 + (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3*(-vop_ref[0][0]) | |
5170 + (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3*(-vop_ref[0][1]) | |
5171 + (1<<(alpha+beta+rho-min_ab-1)); | |
5172 s->sprite_offset[0][1]= (sprite_ref[0][1]<<(alpha+beta+rho-min_ab)) | |
5173 + (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3*(-vop_ref[0][0]) | |
5174 + (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3*(-vop_ref[0][1]) | |
5175 + (1<<(alpha+beta+rho-min_ab-1)); | |
5176 s->sprite_offset[1][0]= (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3*(-2*vop_ref[0][0] + 1) | |
5177 + (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3*(-2*vop_ref[0][1] + 1) | |
5178 + 2*w2*h3*r*sprite_ref[0][0] | |
5179 - 16*w2*h3 | |
5180 + (1<<(alpha+beta+rho-min_ab+1)); | |
5181 s->sprite_offset[1][1]= (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3*(-2*vop_ref[0][0] + 1) | |
5182 + (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3*(-2*vop_ref[0][1] + 1) | |
5183 + 2*w2*h3*r*sprite_ref[0][1] | |
5184 - 16*w2*h3 | |
5185 + (1<<(alpha+beta+rho-min_ab+1)); | |
5186 s->sprite_delta[0][0]= (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3; | |
5187 s->sprite_delta[0][1]= (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3; | |
5188 s->sprite_delta[1][0]= (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3; | |
5189 s->sprite_delta[1][1]= (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3; | |
5190 | |
5191 s->sprite_shift[0]= alpha + beta + rho - min_ab; | |
5192 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
|
5193 break; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5194 } |
255 | 5195 /* try to simplify the situation */ |
753 | 5196 if( s->sprite_delta[0][0] == a<<s->sprite_shift[0] |
5197 && s->sprite_delta[0][1] == 0 | |
5198 && s->sprite_delta[1][0] == 0 | |
5199 && s->sprite_delta[1][1] == a<<s->sprite_shift[0]) | |
255 | 5200 { |
753 | 5201 s->sprite_offset[0][0]>>=s->sprite_shift[0]; |
5202 s->sprite_offset[0][1]>>=s->sprite_shift[0]; | |
5203 s->sprite_offset[1][0]>>=s->sprite_shift[1]; | |
5204 s->sprite_offset[1][1]>>=s->sprite_shift[1]; | |
5205 s->sprite_delta[0][0]= a; | |
5206 s->sprite_delta[0][1]= 0; | |
5207 s->sprite_delta[1][0]= 0; | |
5208 s->sprite_delta[1][1]= a; | |
5209 s->sprite_shift[0]= 0; | |
5210 s->sprite_shift[1]= 0; | |
255 | 5211 s->real_sprite_warping_points=1; |
5212 } | |
753 | 5213 else{ |
5214 int shift_y= 16 - s->sprite_shift[0]; | |
5215 int shift_c= 16 - s->sprite_shift[1]; | |
5216 //printf("shifts %d %d\n", shift_y, shift_c); | |
5217 for(i=0; i<2; i++){ | |
5218 s->sprite_offset[0][i]<<= shift_y; | |
5219 s->sprite_offset[1][i]<<= shift_c; | |
5220 s->sprite_delta[0][i]<<= shift_y; | |
5221 s->sprite_delta[1][i]<<= shift_y; | |
5222 s->sprite_shift[i]= 16; | |
5223 } | |
255 | 5224 s->real_sprite_warping_points= s->num_sprite_warping_points; |
753 | 5225 } |
5226 #if 0 | |
5227 printf("vop:%d:%d %d:%d %d:%d, sprite:%d:%d %d:%d %d:%d, virtual: %d:%d %d:%d\n", | |
5228 vop_ref[0][0], vop_ref[0][1], | |
5229 vop_ref[1][0], vop_ref[1][1], | |
5230 vop_ref[2][0], vop_ref[2][1], | |
5231 sprite_ref[0][0], sprite_ref[0][1], | |
5232 sprite_ref[1][0], sprite_ref[1][1], | |
5233 sprite_ref[2][0], sprite_ref[2][1], | |
5234 virtual_ref[0][0], virtual_ref[0][1], | |
5235 virtual_ref[1][0], virtual_ref[1][1] | |
5236 ); | |
5237 | |
5238 printf("offset: %d:%d , delta: %d %d %d %d, shift %d\n", | |
5239 s->sprite_offset[0][0], s->sprite_offset[0][1], | |
5240 s->sprite_delta[0][0], s->sprite_delta[0][1], | |
5241 s->sprite_delta[1][0], s->sprite_delta[1][1], | |
5242 s->sprite_shift[0] | |
5243 ); | |
5244 #endif | |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5245 } |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5246 |
942 | 5247 static int mpeg4_decode_gop_header(MpegEncContext * s, GetBitContext *gb){ |
5248 int hours, minutes, seconds; | |
5249 | |
5250 hours= get_bits(gb, 5); | |
5251 minutes= get_bits(gb, 6); | |
5252 skip_bits1(gb); | |
5253 seconds= get_bits(gb, 6); | |
5254 | |
5255 s->time_base= seconds + 60*(minutes + 60*hours); | |
5256 | |
5257 skip_bits1(gb); | |
5258 skip_bits1(gb); | |
5259 | |
5260 return 0; | |
5261 } | |
5262 | |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5263 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
|
5264 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
|
5265 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5266 /* vol header */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5267 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
|
5268 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
|
5269 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
|
5270 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
|
5271 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
|
5272 } else { |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5273 vo_ver_id = 1; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5274 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5275 //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
|
5276 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
|
5277 if(s->aspect_ratio_info == FF_ASPECT_EXTENDED){ |
1548 | 5278 s->avctx->sample_aspect_ratio.num= get_bits(gb, 8); // par_width |
5279 s->avctx->sample_aspect_ratio.den= get_bits(gb, 8); // par_height | |
887 | 5280 }else{ |
1548 | 5281 s->avctx->sample_aspect_ratio= pixel_aspect[s->aspect_ratio_info]; |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5282 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5283 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5284 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
|
5285 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
|
5286 if(chroma_format!=1){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5287 av_log(s->avctx, AV_LOG_ERROR, "illegal chroma format\n"); |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5288 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5289 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
|
5290 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
|
5291 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
|
5292 skip_bits1(gb); /* marker */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5293 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
|
5294 skip_bits1(gb); /* marker */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5295 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
|
5296 skip_bits1(gb); /* marker */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5297 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
|
5298 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
|
5299 skip_bits1(gb); /* marker */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5300 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
|
5301 skip_bits1(gb); /* marker */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5302 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5303 }else{ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5304 // 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
|
5305 if(s->picture_number==0) |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5306 s->low_delay=0; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5307 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5308 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5309 s->shape = get_bits(gb, 2); /* vol shape */ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5310 if(s->shape != RECT_SHAPE) av_log(s->avctx, AV_LOG_ERROR, "only rectangular vol supported\n"); |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5311 if(s->shape == GRAY_SHAPE && vo_ver_id != 1){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5312 av_log(s->avctx, AV_LOG_ERROR, "Gray shape not supported\n"); |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5313 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
|
5314 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5315 |
1411 | 5316 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
|
5317 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5318 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
|
5319 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5320 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
|
5321 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
|
5322 s->time_increment_bits = 1; |
1411 | 5323 |
5324 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
|
5325 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5326 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
|
5327 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
|
5328 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5329 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5330 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
|
5331 if (s->shape == RECT_SHAPE) { |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5332 skip_bits1(gb); /* marker */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5333 width = get_bits(gb, 13); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5334 skip_bits1(gb); /* marker */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5335 height = get_bits(gb, 13); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5336 skip_bits1(gb); /* marker */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5337 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
|
5338 s->width = width; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5339 s->height = height; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5340 // 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
|
5341 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5342 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5343 |
1659 | 5344 s->progressive_sequence= |
5345 s->progressive_frame= get_bits1(gb)^1; | |
1237 | 5346 if(!get_bits1(gb) && (s->avctx->debug & FF_DEBUG_PICT_INFO)) |
1644 | 5347 av_log(s->avctx, AV_LOG_INFO, "MPEG4 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
|
5348 if (vo_ver_id == 1) { |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5349 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
|
5350 } else { |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5351 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
|
5352 } |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5353 if(s->vol_sprite_usage==STATIC_SPRITE) av_log(s->avctx, AV_LOG_ERROR, "Static Sprites not supported\n"); |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5354 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
|
5355 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
|
5356 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
|
5357 skip_bits1(gb); /* marker */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5358 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
|
5359 skip_bits1(gb); /* marker */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5360 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
|
5361 skip_bits1(gb); /* marker */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5362 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
|
5363 skip_bits1(gb); /* marker */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5364 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5365 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
|
5366 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
|
5367 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
|
5368 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
|
5369 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
|
5370 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5371 // 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
|
5372 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5373 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
|
5374 s->quant_precision = get_bits(gb, 4); /* quant_precision */ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5375 if(get_bits(gb, 4)!=8) av_log(s->avctx, AV_LOG_ERROR, "N-bit not supported\n"); /* bits_per_pixel */ |
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5376 if(s->quant_precision!=5) av_log(s->avctx, AV_LOG_ERROR, "quant precission %d\n", s->quant_precision); |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5377 } else { |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5378 s->quant_precision = 5; |
0 | 5379 } |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5380 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5381 // 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
|
5382 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5383 if((s->mpeg_quant=get_bits1(gb))){ /* vol_quant_type */ |
1057 | 5384 int i, v; |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5385 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5386 /* load default matrixes */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5387 for(i=0; i<64; i++){ |
1092 | 5388 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
|
5389 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
|
5390 s->intra_matrix[j]= v; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5391 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
|
5392 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5393 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
|
5394 s->inter_matrix[j]= v; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5395 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
|
5396 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5397 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5398 /* load custom intra matrix */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5399 if(get_bits1(gb)){ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5400 int last=0; |
1057 | 5401 for(i=0; i<64; i++){ |
5402 int j; | |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5403 v= get_bits(gb, 8); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5404 if(v==0) break; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5405 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5406 last= v; |
1092 | 5407 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
|
5408 s->intra_matrix[j]= v; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5409 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
|
5410 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5411 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5412 /* replicate last value */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5413 for(; i<64; i++){ |
1092 | 5414 int j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ]; |
1411 | 5415 s->intra_matrix[j]= last; |
5416 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
|
5417 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5418 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5419 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5420 /* load custom non intra matrix */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5421 if(get_bits1(gb)){ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5422 int last=0; |
1057 | 5423 for(i=0; i<64; i++){ |
5424 int j; | |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5425 v= get_bits(gb, 8); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5426 if(v==0) break; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5427 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5428 last= v; |
1092 | 5429 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
|
5430 s->inter_matrix[j]= v; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5431 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
|
5432 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5433 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5434 /* replicate last value */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5435 for(; i<64; i++){ |
1092 | 5436 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
|
5437 s->inter_matrix[j]= last; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5438 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
|
5439 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5440 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5441 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5442 // 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
|
5443 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5444 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5445 if(vo_ver_id != 1) |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5446 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
|
5447 else s->quarter_sample=0; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5448 |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5449 if(!get_bits1(gb)) av_log(s->avctx, AV_LOG_ERROR, "Complexity estimation not supported\n"); |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5450 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5451 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
|
5452 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5453 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
|
5454 if(s->data_partitioning){ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5455 s->rvlc= get_bits1(gb); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5456 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5457 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5458 if(vo_ver_id != 1) { |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5459 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
|
5460 if(s->new_pred){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5461 av_log(s->avctx, AV_LOG_ERROR, "new pred not supported\n"); |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5462 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
|
5463 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
|
5464 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5465 s->reduced_res_vop= get_bits1(gb); |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5466 if(s->reduced_res_vop) av_log(s->avctx, AV_LOG_ERROR, "reduced resolution VOP not supported\n"); |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5467 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5468 else{ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5469 s->new_pred=0; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5470 s->reduced_res_vop= 0; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5471 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5472 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5473 s->scalability= get_bits1(gb); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5474 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5475 if (s->scalability) { |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5476 GetBitContext bak= *gb; |
751 | 5477 int ref_layer_id; |
5478 int ref_layer_sampling_dir; | |
5479 int h_sampling_factor_n; | |
5480 int h_sampling_factor_m; | |
5481 int v_sampling_factor_n; | |
5482 int v_sampling_factor_m; | |
5483 | |
5484 s->hierachy_type= get_bits1(gb); | |
5485 ref_layer_id= get_bits(gb, 4); | |
5486 ref_layer_sampling_dir= get_bits1(gb); | |
5487 h_sampling_factor_n= get_bits(gb, 5); | |
5488 h_sampling_factor_m= get_bits(gb, 5); | |
5489 v_sampling_factor_n= get_bits(gb, 5); | |
5490 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
|
5491 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
|
5492 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5493 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
|
5494 || 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
|
5495 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5496 // 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
|
5497 s->scalability=0; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5498 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5499 *gb= bak; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5500 }else |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5501 av_log(s->avctx, AV_LOG_ERROR, "scalability not supported\n"); |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5502 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5503 // bin shape stuff FIXME |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5504 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5505 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5506 return 0; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5507 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5508 |
1034 | 5509 /** |
5510 * decodes the user data stuff in the header. | |
5511 * allso inits divx/xvid/lavc_version/build | |
5512 */ | |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5513 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
|
5514 char buf[256]; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5515 int i; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5516 int e; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5517 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
|
5518 char last; |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5519 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5520 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
|
5521 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
|
5522 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
|
5523 if(buf[i]==0) break; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5524 skip_bits(gb, 8); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5525 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5526 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
|
5527 |
761 | 5528 /* 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
|
5529 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
|
5530 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
|
5531 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
|
5532 if(e>=2){ |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5533 s->divx_version= ver; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5534 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
|
5535 s->divx_packed= e==3 && last=='p'; |
0 | 5536 } |
761 | 5537 |
5538 /* ffmpeg detection */ | |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5539 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
|
5540 if(e!=4) |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5541 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
|
5542 if(e!=4){ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5543 if(strcmp(buf, "ffmpeg")==0){ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5544 s->ffmpeg_version= 0x000406; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5545 s->lavc_build= 4600; |
63 | 5546 } |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5547 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5548 if(e==4){ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5549 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
|
5550 s->lavc_build= build; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5551 } |
761 | 5552 |
5553 /* xvid detection */ | |
5554 e=sscanf(buf, "XviD%d", &build); | |
5555 if(e==1){ | |
5556 s->xvid_build= build; | |
5557 } | |
5558 | |
255 | 5559 //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
|
5560 return 0; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5561 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5562 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5563 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
|
5564 int time_incr, time_increment; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5565 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5566 s->pict_type = get_bits(gb, 2) + I_TYPE; /* pict type: I = 0 , P = 1 */ |
1346 | 5567 if(s->pict_type==B_TYPE && s->low_delay && s->vol_control_parameters==0 && !(s->flags & CODEC_FLAG_LOW_DELAY)){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5568 av_log(s->avctx, AV_LOG_ERROR, "low_delay flag set, but shouldnt, clearing it\n"); |
365
fdeec2834c79
there are divx5? encoded files without a userdata section but with b-frames :(
michaelni
parents:
364
diff
changeset
|
5569 s->low_delay=0; |
fdeec2834c79
there are divx5? encoded files without a userdata section but with b-frames :(
michaelni
parents:
364
diff
changeset
|
5570 } |
753 | 5571 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
5572 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
|
5573 if(s->partitioned_frame) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
5574 s->decode_mb= mpeg4_decode_partitioned_mb; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
5575 else |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
5576 s->decode_mb= ff_mpeg4_decode_mb; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
5577 |
662
5a158f0d1981
fixing 1/0 if the headers are incomplete (like what M$ encoder generates)
michaelni
parents:
661
diff
changeset
|
5578 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
|
5579 s->time_increment_resolution=1; |
5a158f0d1981
fixing 1/0 if the headers are incomplete (like what M$ encoder generates)
michaelni
parents:
661
diff
changeset
|
5580 // 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
|
5581 } |
262 | 5582 time_incr=0; |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5583 while (get_bits1(gb) != 0) |
0 | 5584 time_incr++; |
5585 | |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5586 check_marker(gb, "before time_increment"); |
1068 | 5587 |
1396 | 5588 if(s->time_increment_bits==0){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5589 av_log(s->avctx, AV_LOG_ERROR, "hmm, seems the headers arnt complete, trying to guess time_increment_bits\n"); |
1068 | 5590 |
5591 for(s->time_increment_bits=1 ;s->time_increment_bits<16; s->time_increment_bits++){ | |
5592 if(show_bits(gb, s->time_increment_bits+1)&1) break; | |
5593 } | |
1396 | 5594 |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5595 av_log(s->avctx, AV_LOG_ERROR, "my guess is %d bits ;)\n",s->time_increment_bits); |
1068 | 5596 } |
5597 | |
1411 | 5598 if(IS_3IV1) time_increment= get_bits1(gb); //FIXME investigate further |
5599 else time_increment= get_bits(gb, s->time_increment_bits); | |
5600 | |
5601 // printf("%d %X\n", s->time_increment_bits, time_increment); | |
697 | 5602 //printf(" type:%d modulo_time_base:%d increment:%d\n", s->pict_type, time_incr, time_increment); |
262 | 5603 if(s->pict_type!=B_TYPE){ |
324 | 5604 s->last_time_base= s->time_base; |
262 | 5605 s->time_base+= time_incr; |
324 | 5606 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
|
5607 if(s->workaround_bugs&FF_BUG_UMP4){ |
700
0fb4c66527e1
autodetect UMP4 (by adding a fourcc field to AVCodecContext)
michaelni
parents:
699
diff
changeset
|
5608 if(s->time < s->last_non_b_time){ |
0fb4c66527e1
autodetect UMP4 (by adding a fourcc field to AVCodecContext)
michaelni
parents:
699
diff
changeset
|
5609 // 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
|
5610 s->time_base++; |
0fb4c66527e1
autodetect UMP4 (by adding a fourcc field to AVCodecContext)
michaelni
parents:
699
diff
changeset
|
5611 s->time+= s->time_increment_resolution; |
0fb4c66527e1
autodetect UMP4 (by adding a fourcc field to AVCodecContext)
michaelni
parents:
699
diff
changeset
|
5612 } |
664 | 5613 } |
324 | 5614 s->pp_time= s->time - s->last_non_b_time; |
5615 s->last_non_b_time= s->time; | |
262 | 5616 }else{ |
324 | 5617 s->time= (s->last_time_base + time_incr)*s->time_increment_resolution + time_increment; |
664 | 5618 s->pb_time= s->pp_time - (s->last_non_b_time - s->time); |
5619 if(s->pp_time <=s->pb_time || s->pp_time <= s->pp_time - s->pb_time || s->pp_time<=0){ | |
335 | 5620 // printf("messed up order, seeking?, skiping current b frame\n"); |
5621 return FRAME_SKIPED; | |
5622 } | |
664 | 5623 |
5624 if(s->t_frame==0) s->t_frame= s->time - s->last_time_base; | |
5625 if(s->t_frame==0) s->t_frame=1; // 1/0 protection | |
5626 //printf("%Ld %Ld %d %d\n", s->last_non_b_time, s->time, s->pp_time, s->t_frame); fflush(stdout); | |
5627 s->pp_field_time= ( ROUNDED_DIV(s->last_non_b_time, s->t_frame) | |
5628 - ROUNDED_DIV(s->last_non_b_time - s->pp_time, s->t_frame))*2; | |
5629 s->pb_field_time= ( ROUNDED_DIV(s->time, s->t_frame) | |
5630 - ROUNDED_DIV(s->last_non_b_time - s->pp_time, s->t_frame))*2; | |
262 | 5631 } |
654 | 5632 |
1586 | 5633 s->current_picture_ptr->pts= s->time*1000LL*1000LL / s->time_increment_resolution; |
942 | 5634 if(s->avctx->debug&FF_DEBUG_PTS) |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5635 av_log(s->avctx, AV_LOG_DEBUG, "MPEG4 PTS: %f\n", s->current_picture_ptr->pts/(1000.0*1000.0)); |
654 | 5636 |
1068 | 5637 check_marker(gb, "before vop_coded"); |
5638 | |
0 | 5639 /* vop coded */ |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5640 if (get_bits1(gb) != 1){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5641 av_log(s->avctx, AV_LOG_ERROR, "vop not coded\n"); |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5642 return FRAME_SKIPED; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5643 } |
664 | 5644 //printf("time %d %d %d || %Ld %Ld %Ld\n", s->time_increment_bits, s->time_increment_resolution, s->time_base, |
5645 //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
|
5646 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
|
5647 || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE))) { |
0 | 5648 /* 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
|
5649 s->no_rounding = get_bits1(gb); |
63 | 5650 } else { |
5651 s->no_rounding = 0; | |
0 | 5652 } |
253
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
5653 //FIXME reduced res stuff |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
5654 |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
5655 if (s->shape != RECT_SHAPE) { |
63 | 5656 if (s->vol_sprite_usage != 1 || s->pict_type != I_TYPE) { |
5657 int width, height, hor_spat_ref, ver_spat_ref; | |
5658 | |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5659 width = get_bits(gb, 13); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5660 skip_bits1(gb); /* marker */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5661 height = get_bits(gb, 13); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5662 skip_bits1(gb); /* marker */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5663 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
|
5664 skip_bits1(gb); /* marker */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5665 ver_spat_ref = get_bits(gb, 13); /* ver_spat_ref */ |
63 | 5666 } |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5667 skip_bits1(gb); /* change_CR_disable */ |
63 | 5668 |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5669 if (get_bits1(gb) != 0) { |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5670 skip_bits(gb, 8); /* constant_alpha_value */ |
63 | 5671 } |
5672 } | |
253
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
5673 //FIXME complexity estimation stuff |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
5674 |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
5675 if (s->shape != BIN_ONLY_SHAPE) { |
1520 | 5676 s->intra_dc_threshold= mpeg4_dc_threshold[ get_bits(gb, 3) ]; |
619
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
5677 if(!s->progressive_sequence){ |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5678 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
|
5679 s->alternate_scan= get_bits1(gb); |
661 | 5680 }else |
5681 s->alternate_scan= 0; | |
253
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
5682 } |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5683 |
718 | 5684 if(s->alternate_scan){ |
1273 | 5685 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_alternate_vertical_scan); |
5686 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_alternate_vertical_scan); | |
5687 ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_vertical_scan); | |
5688 ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan); | |
718 | 5689 } else{ |
1273 | 5690 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_zigzag_direct); |
5691 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_zigzag_direct); | |
5692 ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan); | |
5693 ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan); | |
718 | 5694 } |
5695 | |
253
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
5696 if(s->pict_type == S_TYPE && (s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE)){ |
821 | 5697 mpeg4_decode_sprite_trajectory(s); |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5698 if(s->sprite_brightness_change) av_log(s->avctx, AV_LOG_ERROR, "sprite_brightness_change not supported\n"); |
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5699 if(s->vol_sprite_usage==STATIC_SPRITE) av_log(s->avctx, AV_LOG_ERROR, "static sprite not supported\n"); |
253
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
5700 } |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5701 |
253
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
5702 if (s->shape != BIN_ONLY_SHAPE) { |
1644 | 5703 s->chroma_qscale= 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
|
5704 if(s->qscale==0){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5705 av_log(s->avctx, AV_LOG_ERROR, "Error, header damaged or not MPEG4 header (qscale=0)\n"); |
264
28c5c62b1c4c
support decoding (with mplayer) of 3 .mp4 files from mphq
michaelni
parents:
263
diff
changeset
|
5706 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
|
5707 } |
63 | 5708 |
5709 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
|
5710 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
|
5711 if(s->f_code==0){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5712 av_log(s->avctx, AV_LOG_ERROR, "Error, header damaged or not MPEG4 header (f_code=0)\n"); |
264
28c5c62b1c4c
support decoding (with mplayer) of 3 .mp4 files from mphq
michaelni
parents:
263
diff
changeset
|
5713 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
|
5714 } |
582
5132a4ee50cd
different edge positions fixed with edge emu / dr1
michaelni
parents:
575
diff
changeset
|
5715 }else |
5132a4ee50cd
different edge positions fixed with edge emu / dr1
michaelni
parents:
575
diff
changeset
|
5716 s->f_code=1; |
5132a4ee50cd
different edge positions fixed with edge emu / dr1
michaelni
parents:
575
diff
changeset
|
5717 |
253
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
5718 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
|
5719 s->b_code = get_bits(gb, 3); |
582
5132a4ee50cd
different edge positions fixed with edge emu / dr1
michaelni
parents:
575
diff
changeset
|
5720 }else |
5132a4ee50cd
different edge positions fixed with edge emu / dr1
michaelni
parents:
575
diff
changeset
|
5721 s->b_code=1; |
906 | 5722 |
5723 if(s->avctx->debug&FF_DEBUG_PICT_INFO){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5724 av_log(s->avctx, AV_LOG_DEBUG, "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 dc:%d\n", |
906 | 5725 s->qscale, s->f_code, s->b_code, |
5726 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
|
5727 gb->size_in_bits,s->progressive_sequence, s->alternate_scan, s->top_field_first, |
930 | 5728 s->quarter_sample ? "q" : "h", s->data_partitioning, s->resync_marker, s->num_sprite_warping_points, |
1520 | 5729 s->sprite_warping_accuracy, 1-s->no_rounding, s->vo_type, s->vol_control_parameters ? " VOLC" : " ", s->intra_dc_threshold); |
906 | 5730 } |
5731 | |
253
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
5732 if(!s->scalability){ |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
5733 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
|
5734 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
|
5735 } |
575 | 5736 }else{ |
5737 if(s->enhancement_type){ | |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5738 int load_backward_shape= get_bits1(gb); |
575 | 5739 if(load_backward_shape){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5740 av_log(s->avctx, AV_LOG_ERROR, "load backward shape isnt supported\n"); |
575 | 5741 } |
5742 } | |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5743 skip_bits(gb, 2); //ref_select_code |
63 | 5744 } |
5745 } | |
346
c2f789fe4945
detecting xvid/divx4/opendivx and set low_delay flag
michaelni
parents:
344
diff
changeset
|
5746 /* 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
|
5747 // 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
|
5748 if(s->vo_type==0 && s->vol_control_parameters==0 && s->divx_version==0 && s->picture_number==0){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5749 av_log(s->avctx, AV_LOG_ERROR, "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
|
5750 s->low_delay=1; |
c2f789fe4945
detecting xvid/divx4/opendivx and set low_delay flag
michaelni
parents:
344
diff
changeset
|
5751 } |
c2f789fe4945
detecting xvid/divx4/opendivx and set low_delay flag
michaelni
parents:
344
diff
changeset
|
5752 |
255 | 5753 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
|
5754 |
498 | 5755 s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table; //FIXME add short header support |
5756 s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table; | |
5757 | |
1366
80067f8d6770
fix edge repeating bug for %16!=0 files, this fixes Quicktime mpeg4 (they arent buggy)
michaelni
parents:
1364
diff
changeset
|
5758 if(s->workaround_bugs&FF_BUG_EDGE){ |
582
5132a4ee50cd
different edge positions fixed with edge emu / dr1
michaelni
parents:
575
diff
changeset
|
5759 s->h_edge_pos= s->width; |
5132a4ee50cd
different edge positions fixed with edge emu / dr1
michaelni
parents:
575
diff
changeset
|
5760 s->v_edge_pos= s->height; |
5132a4ee50cd
different edge positions fixed with edge emu / dr1
michaelni
parents:
575
diff
changeset
|
5761 } |
63 | 5762 return 0; |
0 | 5763 } |
5764 | |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5765 /** |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5766 * decode mpeg4 headers |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5767 * @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
|
5768 * 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
|
5769 * 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
|
5770 */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5771 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
|
5772 { |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5773 int startcode, v; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5774 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5775 /* search next start code */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5776 align_get_bits(gb); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5777 startcode = 0xff; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5778 for(;;) { |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5779 v = get_bits(gb, 8); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5780 startcode = ((startcode << 8) | v) & 0xffffffff; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5781 |
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
|
5782 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
|
5783 if(gb->size_in_bits==8 && s->divx_version){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5784 av_log(s->avctx, AV_LOG_ERROR, "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
|
5785 return FRAME_SKIPED; //divx bug |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5786 }else |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5787 return -1; //end of stream |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5788 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5789 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5790 if((startcode&0xFFFFFF00) != 0x100) |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5791 continue; //no startcode |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5792 |
942 | 5793 if(s->avctx->debug&FF_DEBUG_STARTCODE){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5794 av_log(s->avctx, AV_LOG_DEBUG, "startcode: %3X ", startcode); |
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5795 if (startcode<=0x11F) av_log(s->avctx, AV_LOG_DEBUG, "Video Object Start"); |
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5796 else if(startcode<=0x12F) av_log(s->avctx, AV_LOG_DEBUG, "Video Object Layer Start"); |
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5797 else if(startcode<=0x13F) av_log(s->avctx, AV_LOG_DEBUG, "Reserved"); |
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5798 else if(startcode<=0x15F) av_log(s->avctx, AV_LOG_DEBUG, "FGS bp start"); |
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5799 else if(startcode<=0x1AF) av_log(s->avctx, AV_LOG_DEBUG, "Reserved"); |
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5800 else if(startcode==0x1B0) av_log(s->avctx, AV_LOG_DEBUG, "Visual Object Seq Start"); |
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5801 else if(startcode==0x1B1) av_log(s->avctx, AV_LOG_DEBUG, "Visual Object Seq End"); |
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5802 else if(startcode==0x1B2) av_log(s->avctx, AV_LOG_DEBUG, "User Data"); |
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5803 else if(startcode==0x1B3) av_log(s->avctx, AV_LOG_DEBUG, "Group of VOP start"); |
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5804 else if(startcode==0x1B4) av_log(s->avctx, AV_LOG_DEBUG, "Video Session Error"); |
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5805 else if(startcode==0x1B5) av_log(s->avctx, AV_LOG_DEBUG, "Visual Object Start"); |
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5806 else if(startcode==0x1B6) av_log(s->avctx, AV_LOG_DEBUG, "Video Object Plane start"); |
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5807 else if(startcode==0x1B7) av_log(s->avctx, AV_LOG_DEBUG, "slice start"); |
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5808 else if(startcode==0x1B8) av_log(s->avctx, AV_LOG_DEBUG, "extension start"); |
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5809 else if(startcode==0x1B9) av_log(s->avctx, AV_LOG_DEBUG, "fgs start"); |
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5810 else if(startcode==0x1BA) av_log(s->avctx, AV_LOG_DEBUG, "FBA Object start"); |
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5811 else if(startcode==0x1BB) av_log(s->avctx, AV_LOG_DEBUG, "FBA Object Plane start"); |
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5812 else if(startcode==0x1BC) av_log(s->avctx, AV_LOG_DEBUG, "Mesh Object start"); |
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5813 else if(startcode==0x1BD) av_log(s->avctx, AV_LOG_DEBUG, "Mesh Object Plane start"); |
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5814 else if(startcode==0x1BE) av_log(s->avctx, AV_LOG_DEBUG, "Still Textutre Object start"); |
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5815 else if(startcode==0x1BF) av_log(s->avctx, AV_LOG_DEBUG, "Textutre Spatial Layer start"); |
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5816 else if(startcode==0x1C0) av_log(s->avctx, AV_LOG_DEBUG, "Textutre SNR Layer start"); |
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5817 else if(startcode==0x1C1) av_log(s->avctx, AV_LOG_DEBUG, "Textutre Tile start"); |
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5818 else if(startcode==0x1C2) av_log(s->avctx, AV_LOG_DEBUG, "Textutre Shape Layer start"); |
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5819 else if(startcode==0x1C3) av_log(s->avctx, AV_LOG_DEBUG, "stuffing start"); |
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5820 else if(startcode<=0x1C5) av_log(s->avctx, AV_LOG_DEBUG, "reserved"); |
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5821 else if(startcode<=0x1FF) av_log(s->avctx, AV_LOG_DEBUG, "System start"); |
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5822 av_log(s->avctx, AV_LOG_DEBUG, " at %d\n", get_bits_count(gb)); |
942 | 5823 } |
5824 | |
1512 | 5825 if(startcode >= 0x120 && startcode <= 0x12F){ |
1396 | 5826 if(decode_vol_header(s, gb) < 0) |
5827 return -1; | |
1512 | 5828 } |
5829 else if(startcode == USER_DATA_STARTCODE){ | |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5830 decode_user_data(s, gb); |
1512 | 5831 } |
5832 else if(startcode == GOP_STARTCODE){ | |
942 | 5833 mpeg4_decode_gop_header(s, gb); |
1512 | 5834 } |
5835 else if(startcode == VOP_STARTCODE){ | |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5836 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
|
5837 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5838 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5839 align_get_bits(gb); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5840 startcode = 0xff; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5841 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5842 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5843 |
0 | 5844 /* don't understand why they choose a different header ! */ |
5845 int intel_h263_decode_picture_header(MpegEncContext *s) | |
5846 { | |
5847 int format; | |
5848 | |
5849 /* picture header */ | |
1257 | 5850 if (get_bits_long(&s->gb, 22) != 0x20) { |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5851 av_log(s->avctx, AV_LOG_ERROR, "Bad picture start code\n"); |
0 | 5852 return -1; |
355 | 5853 } |
5854 s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */ | |
0 | 5855 |
355 | 5856 if (get_bits1(&s->gb) != 1) { |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5857 av_log(s->avctx, AV_LOG_ERROR, "Bad marker\n"); |
0 | 5858 return -1; /* marker */ |
355 | 5859 } |
5860 if (get_bits1(&s->gb) != 0) { | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5861 av_log(s->avctx, AV_LOG_ERROR, "Bad H263 id\n"); |
0 | 5862 return -1; /* h263 id */ |
355 | 5863 } |
21 | 5864 skip_bits1(&s->gb); /* split screen off */ |
5865 skip_bits1(&s->gb); /* camera off */ | |
5866 skip_bits1(&s->gb); /* freeze picture release off */ | |
0 | 5867 |
5868 format = get_bits(&s->gb, 3); | |
355 | 5869 if (format != 7) { |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5870 av_log(s->avctx, AV_LOG_ERROR, "Intel H263 free format not supported\n"); |
0 | 5871 return -1; |
355 | 5872 } |
0 | 5873 s->h263_plus = 0; |
5874 | |
21 | 5875 s->pict_type = I_TYPE + get_bits1(&s->gb); |
0 | 5876 |
21 | 5877 s->unrestricted_mv = get_bits1(&s->gb); |
0 | 5878 s->h263_long_vectors = s->unrestricted_mv; |
5879 | |
355 | 5880 if (get_bits1(&s->gb) != 0) { |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5881 av_log(s->avctx, AV_LOG_ERROR, "SAC not supported\n"); |
0 | 5882 return -1; /* SAC: off */ |
355 | 5883 } |
5884 if (get_bits1(&s->gb) != 0) { | |
1633 | 5885 s->obmc= 1; |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5886 av_log(s->avctx, AV_LOG_ERROR, "Advanced Prediction Mode not supported\n"); |
1633 | 5887 // return -1; /* advanced prediction mode: off */ |
355 | 5888 } |
5889 if (get_bits1(&s->gb) != 0) { | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5890 av_log(s->avctx, AV_LOG_ERROR, "PB frame mode no supported\n"); |
355 | 5891 return -1; /* PB frame mode */ |
5892 } | |
0 | 5893 |
5894 /* skip unknown header garbage */ | |
21 | 5895 skip_bits(&s->gb, 41); |
0 | 5896 |
1644 | 5897 s->chroma_qscale= s->qscale = get_bits(&s->gb, 5); |
21 | 5898 skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */ |
0 | 5899 |
5900 /* PEI */ | |
21 | 5901 while (get_bits1(&s->gb) != 0) { |
5902 skip_bits(&s->gb, 8); | |
0 | 5903 } |
5904 s->f_code = 1; | |
770
d1770a34e4f6
segfault fix patch by (Juergen Keil <jk at tools dot de>)
michaelni
parents:
766
diff
changeset
|
5905 |
d1770a34e4f6
segfault fix patch by (Juergen Keil <jk at tools dot de>)
michaelni
parents:
766
diff
changeset
|
5906 s->y_dc_scale_table= |
d1770a34e4f6
segfault fix patch by (Juergen Keil <jk at tools dot de>)
michaelni
parents:
766
diff
changeset
|
5907 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
|
5908 |
0 | 5909 return 0; |
5910 } | |
144 | 5911 |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5912 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
|
5913 { |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5914 int format, width, height; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5915 |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5916 /* picture header */ |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5917 if (get_bits_long(&s->gb, 17) != 1) { |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5918 av_log(s->avctx, AV_LOG_ERROR, "Bad picture start code\n"); |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5919 return -1; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5920 } |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5921 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
|
5922 if (format != 0 && format != 1) { |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5923 av_log(s->avctx, AV_LOG_ERROR, "Bad picture format\n"); |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5924 return -1; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5925 } |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5926 s->h263_flv = format+1; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5927 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
|
5928 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
|
5929 switch (format) { |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5930 case 0: |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5931 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
|
5932 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
|
5933 break; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5934 case 1: |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5935 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
|
5936 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
|
5937 break; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5938 case 2: |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5939 width = 352; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5940 height = 288; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5941 break; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5942 case 3: |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5943 width = 176; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5944 height = 144; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5945 break; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5946 case 4: |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5947 width = 128; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5948 height = 96; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5949 break; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5950 case 5: |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5951 width = 320; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5952 height = 240; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5953 break; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5954 case 6: |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5955 width = 160; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5956 height = 120; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5957 break; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5958 default: |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5959 width = height = 0; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5960 break; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5961 } |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5962 if ((width == 0) || (height == 0)) |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5963 return -1; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5964 s->width = width; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5965 s->height = height; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5966 |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5967 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
|
5968 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
|
5969 s->pict_type = P_TYPE; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5970 skip_bits1(&s->gb); /* deblocking flag */ |
1644 | 5971 s->chroma_qscale= s->qscale = get_bits(&s->gb, 5); |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5972 |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5973 s->h263_plus = 0; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5974 |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5975 s->unrestricted_mv = 1; |
1364 | 5976 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
|
5977 |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5978 /* PEI */ |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5979 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
|
5980 skip_bits(&s->gb, 8); |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5981 } |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5982 s->f_code = 1; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5983 |
1364 | 5984 if(s->avctx->debug & FF_DEBUG_PICT_INFO){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5985 av_log(s->avctx, AV_LOG_DEBUG, "%c esc_type:%d, qp:%d num:%d\n", |
1364 | 5986 av_get_pict_type_char(s->pict_type), s->h263_flv-1, s->qscale, s->picture_number); |
5987 } | |
5988 | |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5989 s->y_dc_scale_table= |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5990 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
|
5991 |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5992 return 0; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
5993 } |