Mercurial > libavcodec.hg
annotate h263.c @ 9757:8e4d442554b3 libavcodec
Use FFMIN
author | reimar |
---|---|
date | Sun, 31 May 2009 09:57:42 +0000 |
parents | 483ba97736f8 |
children | c78fd9154378 |
rev | line source |
---|---|
0 | 1 /* |
2 * H263/MPEG4 backend for ffmpeg encoder and decoder | |
8629
04423b2f6e0b
cosmetics: Remove pointless period after copyright statement non-sentences.
diego
parents:
8627
diff
changeset
|
3 * Copyright (c) 2000,2001 Fabrice Bellard |
78 | 4 * H263+ support. |
8629
04423b2f6e0b
cosmetics: Remove pointless period after copyright statement non-sentences.
diego
parents:
8627
diff
changeset
|
5 * Copyright (c) 2001 Juan J. Sierralta P |
1739
07a484280a82
copyright year update of the files i touched and remembered, things look annoyingly unmaintained otherwise
michael
parents:
1708
diff
changeset
|
6 * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at> |
0 | 7 * |
5214 | 8 * ac prediction encoding, B-frame support, error resilience, optimizations, |
9 * qpel decoding, gmc decoding, interlaced decoding | |
10 * by Michael Niedermayer <michaelni@gmx.at> | |
11 * | |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3791
diff
changeset
|
12 * This file is part of FFmpeg. |
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3791
diff
changeset
|
13 * |
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3791
diff
changeset
|
14 * FFmpeg is free software; you can redistribute it and/or |
429 | 15 * modify it under the terms of the GNU Lesser General Public |
16 * License as published by the Free Software Foundation; either | |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3791
diff
changeset
|
17 * version 2.1 of the License, or (at your option) any later version. |
0 | 18 * |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3791
diff
changeset
|
19 * FFmpeg is distributed in the hope that it will be useful, |
0 | 20 * but WITHOUT ANY WARRANTY; without even the implied warranty of |
429 | 21 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
22 * Lesser General Public License for more details. | |
0 | 23 * |
429 | 24 * You should have received a copy of the GNU Lesser General Public |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3791
diff
changeset
|
25 * License along with FFmpeg; if not, write to the Free Software |
3036
0b546eab515d
Update licensing information: The FSF changed postal address.
diego
parents:
3024
diff
changeset
|
26 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
0 | 27 */ |
1034 | 28 |
29 /** | |
8718
e9d9d946f213
Use full internal pathname in doxygen @file directives.
diego
parents:
8691
diff
changeset
|
30 * @file libavcodec/h263.c |
1106 | 31 * h263/mpeg4 codec. |
1034 | 32 */ |
2967 | 33 |
355 | 34 //#define DEBUG |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
35 #include <limits.h> |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
36 |
0 | 37 #include "dsputil.h" |
38 #include "avcodec.h" | |
39 #include "mpegvideo.h" | |
40 #include "h263data.h" | |
41 #include "mpeg4data.h" | |
8627
d6bab465b82c
moves mid_pred() into mathops.h (with arch specific code split by directory)
aurel
parents:
8612
diff
changeset
|
42 #include "mathops.h" |
9103
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
43 #include "unary.h" |
0 | 44 |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
45 //#undef NDEBUG |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
46 //#include <assert.h> |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
47 |
544 | 48 #define INTRA_MCBPC_VLC_BITS 6 |
1482 | 49 #define INTER_MCBPC_VLC_BITS 7 |
544 | 50 #define CBPY_VLC_BITS 6 |
51 #define MV_VLC_BITS 9 | |
52 #define DC_VLC_BITS 9 | |
53 #define SPRITE_TRAJ_VLC_BITS 6 | |
54 #define MB_TYPE_B_VLC_BITS 4 | |
55 #define TEX_VLC_BITS 9 | |
1655 | 56 #define H263_MBTYPE_B_VLC_BITS 6 |
57 #define CBPC_B_VLC_BITS 3 | |
544 | 58 |
0 | 59 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
|
60 int n); |
78 | 61 static void h263p_encode_umotion(MpegEncContext * s, int val); |
648
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
62 static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, |
2967 | 63 int n, int dc, uint8_t *scan_table, |
453 | 64 PutBitContext *dc_pb, PutBitContext *ac_pb); |
3777 | 65 static int mpeg4_get_block_length(MpegEncContext * s, DCTELEM * block, int n, int intra_dc, |
66 uint8_t *scan_table); | |
815
78accc54493b
put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents:
770
diff
changeset
|
67 |
262 | 68 static int h263_decode_motion(MpegEncContext * s, int pred, int fcode); |
78 | 69 static int h263p_decode_umotion(MpegEncContext * s, int pred); |
0 | 70 static int h263_decode_block(MpegEncContext * s, DCTELEM * block, |
71 int n, int coded); | |
453 | 72 static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr); |
73 static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block, | |
1132 | 74 int n, int coded, int intra, int rvlc); |
8739
037e54d6c9c3
Remove pointless '#if CONFIG_ENCODERS' around forward declarations.
diego
parents:
8718
diff
changeset
|
75 |
3781 | 76 static int h263_pred_dc(MpegEncContext * s, int n, int16_t **dc_val_ptr); |
1424 | 77 static void mpeg4_encode_visual_object_header(MpegEncContext * s); |
78 static void mpeg4_encode_vol_header(MpegEncContext * s, int vo_number, int vol_number); | |
8739
037e54d6c9c3
Remove pointless '#if CONFIG_ENCODERS' around forward declarations.
diego
parents:
8718
diff
changeset
|
79 |
1914 | 80 static void mpeg4_decode_sprite_trajectory(MpegEncContext * s, GetBitContext *gb); |
2003 | 81 static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, int level, int *dir_ptr, int encoding); |
1064 | 82 |
8590 | 83 #if CONFIG_ENCODERS |
1064 | 84 static uint8_t uni_DCtab_lum_len[512]; |
85 static uint8_t uni_DCtab_chrom_len[512]; | |
86 static uint16_t uni_DCtab_lum_bits[512]; | |
87 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
|
88 |
4655 | 89 static uint8_t mv_penalty[MAX_FCODE+1][MAX_MV*2+1]; |
1064 | 90 static uint8_t fcode_tab[MAX_MV*2+1]; |
91 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
|
92 |
945 | 93 static uint32_t uni_mpeg4_intra_rl_bits[64*64*2*2]; |
94 static uint8_t uni_mpeg4_intra_rl_len [64*64*2*2]; | |
95 static uint32_t uni_mpeg4_inter_rl_bits[64*64*2*2]; | |
96 static uint8_t uni_mpeg4_inter_rl_len [64*64*2*2]; | |
2253 | 97 static uint8_t uni_h263_intra_aic_rl_len [64*64*2*2]; |
98 static uint8_t uni_h263_inter_rl_len [64*64*2*2]; | |
945 | 99 //#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
|
100 //#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run) + (level)*64) |
945 | 101 #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
|
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 /* 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
|
104 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
|
105 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
|
106 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
|
107 |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
108 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
|
109 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
|
110 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
|
111 */ |
815
78accc54493b
put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents:
770
diff
changeset
|
112 #endif |
78accc54493b
put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents:
770
diff
changeset
|
113 |
4672 | 114 static uint8_t static_rl_table_store[5][2][2*MAX_RUN + MAX_LEVEL + 3]; |
115 | |
2646
c735e3e60ca7
Even More spelling errors. patch by (Kevin Baragona <kevinmb500 gawab com)
michael
parents:
2639
diff
changeset
|
116 #if 0 //3IV1 is quite rare and it slows things down a tiny bit |
8612 | 117 #define IS_3IV1 s->codec_tag == AV_RL32("3IV1") |
2967 | 118 #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
|
119 #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
|
120 #endif |
293 | 121 |
0 | 122 int h263_get_picture_format(int width, int height) |
123 { | |
124 int format; | |
125 | |
126 if (width == 128 && height == 96) | |
355 | 127 format = 1; |
0 | 128 else if (width == 176 && height == 144) |
355 | 129 format = 2; |
0 | 130 else if (width == 352 && height == 288) |
355 | 131 format = 3; |
0 | 132 else if (width == 704 && height == 576) |
355 | 133 format = 4; |
0 | 134 else if (width == 1408 && height == 1152) |
355 | 135 format = 5; |
0 | 136 else |
137 format = 7; | |
138 return format; | |
139 } | |
140 | |
5403 | 141 static void show_pict_info(MpegEncContext *s){ |
142 av_log(s->avctx, AV_LOG_DEBUG, "qp:%d %c size:%d rnd:%d%s%s%s%s%s%s%s%s%s %d/%d\n", | |
143 s->qscale, av_get_pict_type_char(s->pict_type), | |
144 s->gb.size_in_bits, 1-s->no_rounding, | |
145 s->obmc ? " AP" : "", | |
146 s->umvplus ? " UMV" : "", | |
147 s->h263_long_vectors ? " LONG" : "", | |
148 s->h263_plus ? " +" : "", | |
149 s->h263_aic ? " AIC" : "", | |
150 s->alt_inter_vlc ? " AIV" : "", | |
151 s->modified_quant ? " MQ" : "", | |
152 s->loop_filter ? " LOOP" : "", | |
153 s->h263_slice_structured ? " SS" : "", | |
154 s->avctx->time_base.den, s->avctx->time_base.num | |
155 ); | |
156 } | |
157 | |
8590 | 158 #if CONFIG_ENCODERS |
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
|
159 |
1548 | 160 static void aspect_to_info(MpegEncContext * s, AVRational aspect){ |
887 | 161 int i; |
162 | |
1548 | 163 if(aspect.num==0) aspect= (AVRational){1,1}; |
164 | |
887 | 165 for(i=1; i<6; i++){ |
1548 | 166 if(av_cmp_q(pixel_aspect[i], aspect) == 0){ |
887 | 167 s->aspect_ratio_info=i; |
168 return; | |
169 } | |
170 } | |
2967 | 171 |
887 | 172 s->aspect_ratio_info= FF_ASPECT_EXTENDED; |
880 | 173 } |
174 | |
1354 | 175 void ff_flv_encode_picture_header(MpegEncContext * s, int picture_number) |
0 | 176 { |
1354 | 177 int format; |
178 | |
179 align_put_bits(&s->pb); | |
180 | |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
181 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
|
182 put_bits(&s->pb, 5, (s->h263_flv-1)); /* 0: h263 escape codes 1: 11-bit escape codes */ |
2637 | 183 put_bits(&s->pb, 8, (((int64_t)s->picture_number * 30 * s->avctx->time_base.num) / //FIXME use timestamp |
184 s->avctx->time_base.den) & 0xff); /* TemporalReference */ | |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
185 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
|
186 format = 2; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
187 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
|
188 format = 3; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
189 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
|
190 format = 4; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
191 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
|
192 format = 5; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
193 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
|
194 format = 6; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
195 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
|
196 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
|
197 else |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
198 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
|
199 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
|
200 if (format == 0) { |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
201 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
|
202 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
|
203 } else if (format == 1) { |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
204 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
|
205 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
|
206 } |
6481 | 207 put_bits(&s->pb, 2, s->pict_type == FF_P_TYPE); /* PictureType */ |
1390
39d07c0263de
patch for flv deblocking by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1389
diff
changeset
|
208 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
|
209 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
|
210 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
|
211 |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
212 if(s->h263_aic){ |
2967 | 213 s->y_dc_scale_table= |
1639 | 214 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
|
215 }else{ |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
216 s->y_dc_scale_table= |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
217 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
|
218 } |
1354 | 219 } |
220 | |
221 void h263_encode_picture_header(MpegEncContext * s, int picture_number) | |
222 { | |
1872 | 223 int format, coded_frame_rate, coded_frame_rate_base, i, temp_ref; |
224 int best_clock_code=1; | |
225 int best_divisor=60; | |
226 int best_error= INT_MAX; | |
2967 | 227 |
1872 | 228 if(s->h263_plus){ |
229 for(i=0; i<2; i++){ | |
230 int div, error; | |
2637 | 231 div= (s->avctx->time_base.num*1800000LL + 500LL*s->avctx->time_base.den) / ((1000LL+i)*s->avctx->time_base.den); |
5075
33d50e0e1823
Correct the parameter order for the call to "av_clip".
takis
parents:
4984
diff
changeset
|
232 div= av_clip(div, 1, 127); |
4001 | 233 error= FFABS(s->avctx->time_base.num*1800000LL - (1000LL+i)*s->avctx->time_base.den*div); |
1872 | 234 if(error < best_error){ |
235 best_error= error; | |
236 best_divisor= div; | |
237 best_clock_code= i; | |
238 } | |
239 } | |
240 } | |
241 s->custom_pcf= best_clock_code!=1 || best_divisor!=60; | |
242 coded_frame_rate= 1800000; | |
243 coded_frame_rate_base= (1000+best_clock_code)*best_divisor; | |
1354 | 244 |
245 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
|
246 |
231 | 247 /* Update the pointer to last GOB */ |
9431 | 248 s->ptr_lastgob = put_bits_ptr(&s->pb); |
231 | 249 put_bits(&s->pb, 22, 0x20); /* PSC */ |
2637 | 250 temp_ref= s->picture_number * (int64_t)coded_frame_rate * s->avctx->time_base.num / //FIXME use timestamp |
251 (coded_frame_rate_base * (int64_t)s->avctx->time_base.den); | |
7260
3ec34b551aae
bitstream: move put_sbits() from flacenc.c to bitstream.h and use it
ramiro
parents:
7098
diff
changeset
|
252 put_sbits(&s->pb, 8, temp_ref); /* TemporalReference */ |
0 | 253 |
2979 | 254 put_bits(&s->pb, 1, 1); /* marker */ |
255 put_bits(&s->pb, 1, 0); /* h263 id */ | |
256 put_bits(&s->pb, 1, 0); /* split screen off */ | |
257 put_bits(&s->pb, 1, 0); /* camera off */ | |
258 put_bits(&s->pb, 1, 0); /* freeze picture release off */ | |
2967 | 259 |
78 | 260 format = h263_get_picture_format(s->width, s->height); |
0 | 261 if (!s->h263_plus) { |
262 /* H.263v1 */ | |
263 put_bits(&s->pb, 3, format); | |
6481 | 264 put_bits(&s->pb, 1, (s->pict_type == FF_P_TYPE)); |
0 | 265 /* By now UMV IS DISABLED ON H.263v1, since the restrictions |
266 of H.263v1 UMV implies to check the predicted MV after | |
267 calculation of the current MB to see if we're on the limits */ | |
2979 | 268 put_bits(&s->pb, 1, 0); /* Unrestricted Motion Vector: off */ |
269 put_bits(&s->pb, 1, 0); /* SAC: off */ | |
270 put_bits(&s->pb, 1, s->obmc); /* Advanced Prediction */ | |
271 put_bits(&s->pb, 1, 0); /* only I/P frames, no PB frame */ | |
0 | 272 put_bits(&s->pb, 5, s->qscale); |
2979 | 273 put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */ |
0 | 274 } else { |
1872 | 275 int ufep=1; |
0 | 276 /* H.263v2 */ |
277 /* H.263 Plus PTYPE */ | |
2967 | 278 |
0 | 279 put_bits(&s->pb, 3, 7); |
1872 | 280 put_bits(&s->pb,3,ufep); /* Update Full Extended PTYPE */ |
78 | 281 if (format == 7) |
282 put_bits(&s->pb,3,6); /* Custom Source Format */ | |
283 else | |
284 put_bits(&s->pb, 3, format); | |
2967 | 285 |
1872 | 286 put_bits(&s->pb,1, s->custom_pcf); |
1661 | 287 put_bits(&s->pb,1, s->umvplus); /* Unrestricted Motion Vector */ |
0 | 288 put_bits(&s->pb,1,0); /* SAC: off */ |
1633 | 289 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
|
290 put_bits(&s->pb,1,s->h263_aic); /* Advanced Intra Coding */ |
1644 | 291 put_bits(&s->pb,1,s->loop_filter); /* Deblocking Filter */ |
1661 | 292 put_bits(&s->pb,1,s->h263_slice_structured); /* Slice Structured */ |
0 | 293 put_bits(&s->pb,1,0); /* Reference Picture Selection: off */ |
294 put_bits(&s->pb,1,0); /* Independent Segment Decoding: off */ | |
1637 | 295 put_bits(&s->pb,1,s->alt_inter_vlc); /* Alternative Inter VLC */ |
1644 | 296 put_bits(&s->pb,1,s->modified_quant); /* Modified Quantization: */ |
0 | 297 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */ |
298 put_bits(&s->pb,3,0); /* Reserved */ | |
2967 | 299 |
6481 | 300 put_bits(&s->pb, 3, s->pict_type == FF_P_TYPE); |
2967 | 301 |
0 | 302 put_bits(&s->pb,1,0); /* Reference Picture Resampling: off */ |
303 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
|
304 put_bits(&s->pb,1,s->no_rounding); /* Rounding Type */ |
0 | 305 put_bits(&s->pb,2,0); /* Reserved */ |
306 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */ | |
2967 | 307 |
0 | 308 /* This should be here if PLUSPTYPE */ |
2979 | 309 put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */ |
310 | |
311 if (format == 7) { | |
78 | 312 /* Custom Picture Format (CPFMT) */ |
1548 | 313 aspect_to_info(s, s->avctx->sample_aspect_ratio); |
880 | 314 |
315 put_bits(&s->pb,4,s->aspect_ratio_info); | |
78 | 316 put_bits(&s->pb,9,(s->width >> 2) - 1); |
317 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */ | |
318 put_bits(&s->pb,9,(s->height >> 2)); | |
1548 | 319 if (s->aspect_ratio_info == FF_ASPECT_EXTENDED){ |
320 put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.num); | |
321 put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.den); | |
2979 | 322 } |
78 | 323 } |
1872 | 324 if(s->custom_pcf){ |
325 if(ufep){ | |
326 put_bits(&s->pb, 1, best_clock_code); | |
327 put_bits(&s->pb, 7, best_divisor); | |
328 } | |
7260
3ec34b551aae
bitstream: move put_sbits() from flacenc.c to bitstream.h and use it
ramiro
parents:
7098
diff
changeset
|
329 put_sbits(&s->pb, 2, temp_ref>>8); |
1872 | 330 } |
2967 | 331 |
0 | 332 /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */ |
79
82e579c37bc3
Moved some H.263+ variables to MpegEncContext to be thread-safe.
pulento
parents:
78
diff
changeset
|
333 if (s->umvplus) |
1089 | 334 // put_bits(&s->pb,1,1); /* Limited according tables of Annex D */ |
1644 | 335 //FIXME check actual requested range |
1089 | 336 put_bits(&s->pb,2,1); /* unlimited */ |
1661 | 337 if(s->h263_slice_structured) |
338 put_bits(&s->pb,2,0); /* no weird submodes */ | |
1089 | 339 |
0 | 340 put_bits(&s->pb, 5, s->qscale); |
341 } | |
342 | |
2979 | 343 put_bits(&s->pb, 1, 0); /* no PEI */ |
498 | 344 |
1670 | 345 if(s->h263_slice_structured){ |
346 put_bits(&s->pb, 1, 1); | |
2967 | 347 |
1670 | 348 assert(s->mb_x == 0 && s->mb_y == 0); |
349 ff_h263_encode_mba(s); | |
350 | |
351 put_bits(&s->pb, 1, 1); | |
352 } | |
353 | |
498 | 354 if(s->h263_aic){ |
2967 | 355 s->y_dc_scale_table= |
1639 | 356 s->c_dc_scale_table= ff_aic_dc_scale_table; |
498 | 357 }else{ |
358 s->y_dc_scale_table= | |
359 s->c_dc_scale_table= ff_mpeg1_dc_scale_table; | |
360 } | |
0 | 361 } |
362 | |
766 | 363 /** |
364 * Encodes a group of blocks header. | |
365 */ | |
1661 | 366 void h263_encode_gob_header(MpegEncContext * s, int mb_line) |
162 | 367 { |
1661 | 368 put_bits(&s->pb, 17, 1); /* GBSC */ |
369 | |
370 if(s->h263_slice_structured){ | |
371 put_bits(&s->pb, 1, 1); | |
372 | |
373 ff_h263_encode_mba(s); | |
374 | |
375 if(s->mb_num > 1583) | |
376 put_bits(&s->pb, 1, 1); | |
377 put_bits(&s->pb, 5, s->qscale); /* GQUANT */ | |
378 put_bits(&s->pb, 1, 1); | |
6481 | 379 put_bits(&s->pb, 2, s->pict_type == FF_I_TYPE); /* GFID */ |
1661 | 380 }else{ |
381 int gob_number= mb_line / s->gob_index; | |
382 | |
383 put_bits(&s->pb, 5, gob_number); /* GN */ | |
6481 | 384 put_bits(&s->pb, 2, s->pict_type == FF_I_TYPE); /* GFID */ |
1661 | 385 put_bits(&s->pb, 5, s->qscale); /* GQUANT */ |
386 } | |
162 | 387 } |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
388 |
1492 | 389 static inline int get_block_rate(MpegEncContext * s, DCTELEM block[64], int block_last_index, uint8_t scantable[64]){ |
390 int last=0; | |
391 int j; | |
392 int rate=0; | |
393 | |
394 for(j=1; j<=block_last_index; j++){ | |
395 const int index= scantable[j]; | |
396 int level= block[index]; | |
397 if(level){ | |
398 level+= 64; | |
399 if((level&(~127)) == 0){ | |
400 if(j<block_last_index) rate+= s->intra_ac_vlc_length [UNI_AC_ENC_INDEX(j-last-1, level)]; | |
401 else rate+= s->intra_ac_vlc_last_length[UNI_AC_ENC_INDEX(j-last-1, level)]; | |
402 }else | |
403 rate += s->ac_esc_length; | |
404 | |
405 last= j; | |
406 } | |
407 } | |
2967 | 408 |
1492 | 409 return rate; |
410 } | |
411 | |
412 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
|
413 { |
1492 | 414 int score= 0; |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
415 int i, n; |
903 | 416 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
|
417 |
1492 | 418 memcpy(zigzag_last_index, s->block_last_index, sizeof(int)*6); |
2967 | 419 |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
420 for(n=0; n<6; n++){ |
1064 | 421 int16_t *ac_val, *ac_val1; |
2967 | 422 |
1492 | 423 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
|
424 |
266 | 425 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
|
426 ac_val1= ac_val; |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
427 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
|
428 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
|
429 /* top prediction */ |
266 | 430 ac_val-= s->block_wrap[n]*16; |
903 | 431 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
|
432 /* same qscale */ |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
433 for(i=1; i<8; i++){ |
1092 | 434 const int level= block[n][s->dsp.idct_permutation[i ]]; |
1492 | 435 block[n][s->dsp.idct_permutation[i ]] = level - ac_val[i+8]; |
1092 | 436 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
|
437 ac_val1[i+8]= level; |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
438 } |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
439 }else{ |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
440 /* different qscale, we must rescale */ |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
441 for(i=1; i<8; i++){ |
1092 | 442 const int level= block[n][s->dsp.idct_permutation[i ]]; |
1492 | 443 block[n][s->dsp.idct_permutation[i ]] = level - ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale); |
1092 | 444 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
|
445 ac_val1[i+8]= level; |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
446 } |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
447 } |
1492 | 448 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
|
449 }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
|
450 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
|
451 /* left prediction */ |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
452 ac_val-= 16; |
903 | 453 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
|
454 /* same qscale */ |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
455 for(i=1; i<8; i++){ |
1092 | 456 const int level= block[n][s->dsp.idct_permutation[i<<3]]; |
1492 | 457 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
|
458 ac_val1[i ]= level; |
1092 | 459 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
|
460 } |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
461 }else{ |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
462 /* different qscale, we must rescale */ |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
463 for(i=1; i<8; i++){ |
1092 | 464 const int level= block[n][s->dsp.idct_permutation[i<<3]]; |
1492 | 465 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
|
466 ac_val1[i ]= level; |
1092 | 467 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
|
468 } |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
469 } |
1492 | 470 st[n]= s->intra_v_scantable.permutated; |
471 } | |
472 | |
473 for(i=63; i>0; i--) //FIXME optimize | |
474 if(block[n][ st[n][i] ]) break; | |
475 s->block_last_index[n]= i; | |
476 | |
477 score += get_block_rate(s, block[n], s->block_last_index[n], st[n]); | |
478 } | |
479 | |
480 return score < 0; | |
481 } | |
482 | |
483 static inline void restore_ac_coeffs(MpegEncContext * s, DCTELEM block[6][64], int dir[6], uint8_t *st[6], int zigzag_last_index[6]) | |
484 { | |
485 int i, n; | |
486 memcpy(s->block_last_index, zigzag_last_index, sizeof(int)*6); | |
487 | |
488 for(n=0; n<6; n++){ | |
489 int16_t *ac_val = s->ac_val[0][0] + s->block_index[n] * 16; | |
490 | |
491 st[n]= s->intra_scantable.permutated; | |
492 if(dir[n]){ | |
493 /* top prediction */ | |
494 for(i=1; i<8; i++){ | |
495 block[n][s->dsp.idct_permutation[i ]] = ac_val[i+8]; | |
496 } | |
497 }else{ | |
498 /* left prediction */ | |
499 for(i=1; i<8; i++){ | |
500 block[n][s->dsp.idct_permutation[i<<3]]= ac_val[i ]; | |
501 } | |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
502 } |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
503 } |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
504 } |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
505 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
506 /** |
4316 | 507 * init s->current_picture.qscale_table from s->lambda_table |
508 */ | |
509 static void ff_init_qscale_tab(MpegEncContext *s){ | |
510 int8_t * const qscale_table= s->current_picture.qscale_table; | |
511 int i; | |
512 | |
513 for(i=0; i<s->mb_num; i++){ | |
514 unsigned int lam= s->lambda_table[ s->mb_index2xy[i] ]; | |
515 int qp= (lam*139 + FF_LAMBDA_SCALE*64) >> (FF_LAMBDA_SHIFT + 7); | |
4594 | 516 qscale_table[ s->mb_index2xy[i] ]= av_clip(qp, s->avctx->qmin, s->avctx->qmax); |
4316 | 517 } |
518 } | |
519 | |
520 /** | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
521 * 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
|
522 */ |
695 | 523 void ff_clean_h263_qscales(MpegEncContext *s){ |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
524 int i; |
903 | 525 int8_t * const qscale_table= s->current_picture.qscale_table; |
2967 | 526 |
4316 | 527 ff_init_qscale_tab(s); |
528 | |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
529 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
|
530 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
|
531 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
|
532 } |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
533 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
|
534 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
|
535 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
|
536 } |
1983 | 537 |
538 if(s->codec_id != CODEC_ID_H263P){ | |
539 for(i=1; i<s->mb_num; i++){ | |
540 int mb_xy= s->mb_index2xy[i]; | |
2967 | 541 |
1983 | 542 if(qscale_table[mb_xy] != qscale_table[s->mb_index2xy[i-1]] && (s->mb_type[mb_xy]&CANDIDATE_MB_TYPE_INTER4V)){ |
543 s->mb_type[mb_xy]|= CANDIDATE_MB_TYPE_INTER; | |
544 } | |
545 } | |
546 } | |
695 | 547 } |
548 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
549 /** |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
550 * 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
|
551 */ |
695 | 552 void ff_clean_mpeg4_qscales(MpegEncContext *s){ |
553 int i; | |
903 | 554 int8_t * const qscale_table= s->current_picture.qscale_table; |
555 | |
695 | 556 ff_clean_h263_qscales(s); |
2967 | 557 |
6481 | 558 if(s->pict_type== FF_B_TYPE){ |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
559 int odd=0; |
2646
c735e3e60ca7
Even More spelling errors. patch by (Kevin Baragona <kevinmb500 gawab com)
michael
parents:
2639
diff
changeset
|
560 /* ok, come on, this isn't funny anymore, there's more code for handling this mpeg4 mess than for the actual adaptive quantization */ |
2967 | 561 |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
562 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
|
563 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
|
564 odd += qscale_table[mb_xy]&1; |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
565 } |
2967 | 566 |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
567 if(2*odd > s->mb_num) odd=1; |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
568 else odd=0; |
2967 | 569 |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
570 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
|
571 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
|
572 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
|
573 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
|
574 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
|
575 qscale_table[mb_xy]= 31; |
2967 | 576 } |
577 | |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
578 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
|
579 int mb_xy= s->mb_index2xy[i]; |
1708 | 580 if(qscale_table[mb_xy] != qscale_table[s->mb_index2xy[i-1]] && (s->mb_type[mb_xy]&CANDIDATE_MB_TYPE_DIRECT)){ |
581 s->mb_type[mb_xy]|= CANDIDATE_MB_TYPE_BIDIR; | |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
582 } |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
583 } |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
584 } |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
585 } |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
586 |
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
|
587 #endif //CONFIG_ENCODERS |
3247 | 588 |
8042 | 589 #define tab_size ((signed)FF_ARRAY_ELEMS(s->direct_scale_mv[0])) |
3255
183e3eb0824a
100l to loren. at least this fixes the compile error, but the code is still broken (decoding buggy/crashing)
rfelker
parents:
3247
diff
changeset
|
590 #define tab_bias (tab_size/2) |
183e3eb0824a
100l to loren. at least this fixes the compile error, but the code is still broken (decoding buggy/crashing)
rfelker
parents:
3247
diff
changeset
|
591 |
3791
b1d5ef809e11
fix rv20 b frames (broke since r5264 Mon Apr 3 07:52:24 2006 UTC 2x faster ff_mpeg4_set_direct_mv)
michael
parents:
3781
diff
changeset
|
592 void ff_mpeg4_init_direct_mv(MpegEncContext *s){ |
3247 | 593 int i; |
594 for(i=0; i<tab_size; i++){ | |
595 s->direct_scale_mv[0][i] = (i-tab_bias)*s->pb_time/s->pp_time; | |
596 s->direct_scale_mv[1][i] = (i-tab_bias)*(s->pb_time-s->pp_time)/s->pp_time; | |
597 } | |
598 } | |
599 | |
600 static inline void ff_mpeg4_set_one_direct_mv(MpegEncContext *s, int mx, int my, int i){ | |
601 int xy= s->block_index[i]; | |
602 uint16_t time_pp= s->pp_time; | |
603 uint16_t time_pb= s->pb_time; | |
604 int p_mx, p_my; | |
605 | |
606 p_mx= s->next_picture.motion_val[0][xy][0]; | |
607 if((unsigned)(p_mx + tab_bias) < tab_size){ | |
608 s->mv[0][i][0] = s->direct_scale_mv[0][p_mx + tab_bias] + mx; | |
609 s->mv[1][i][0] = mx ? s->mv[0][i][0] - p_mx | |
610 : s->direct_scale_mv[1][p_mx + tab_bias]; | |
611 }else{ | |
612 s->mv[0][i][0] = p_mx*time_pb/time_pp + mx; | |
613 s->mv[1][i][0] = mx ? s->mv[0][i][0] - p_mx | |
614 : p_mx*(time_pb - time_pp)/time_pp; | |
615 } | |
616 p_my= s->next_picture.motion_val[0][xy][1]; | |
617 if((unsigned)(p_my + tab_bias) < tab_size){ | |
618 s->mv[0][i][1] = s->direct_scale_mv[0][p_my + tab_bias] + my; | |
619 s->mv[1][i][1] = my ? s->mv[0][i][1] - p_my | |
620 : s->direct_scale_mv[1][p_my + tab_bias]; | |
621 }else{ | |
622 s->mv[0][i][1] = p_my*time_pb/time_pp + my; | |
623 s->mv[1][i][1] = my ? s->mv[0][i][1] - p_my | |
624 : p_my*(time_pb - time_pp)/time_pp; | |
625 } | |
626 } | |
627 | |
3255
183e3eb0824a
100l to loren. at least this fixes the compile error, but the code is still broken (decoding buggy/crashing)
rfelker
parents:
3247
diff
changeset
|
628 #undef tab_size |
183e3eb0824a
100l to loren. at least this fixes the compile error, but the code is still broken (decoding buggy/crashing)
rfelker
parents:
3247
diff
changeset
|
629 #undef tab_bias |
183e3eb0824a
100l to loren. at least this fixes the compile error, but the code is still broken (decoding buggy/crashing)
rfelker
parents:
3247
diff
changeset
|
630 |
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
|
631 /** |
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
|
632 * |
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
|
633 * @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
|
634 */ |
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
|
635 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
|
636 const int mb_index= s->mb_x + s->mb_y*s->mb_stride; |
1708 | 637 const int colocated_mb_type= s->next_picture.mb_type[mb_index]; |
9484
fb240cb99bcf
Remove useless init from ff_mpeg4_set_direct_mv() found by CSA.
michael
parents:
9481
diff
changeset
|
638 uint16_t time_pp; |
fb240cb99bcf
Remove useless init from ff_mpeg4_set_direct_mv() found by CSA.
michael
parents:
9481
diff
changeset
|
639 uint16_t time_pb; |
936 | 640 int i; |
2967 | 641 |
936 | 642 //FIXME avoid divides |
3247 | 643 // try special case with shifts for 1 and 3 B-frames? |
2967 | 644 |
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
|
645 if(IS_8X8(colocated_mb_type)){ |
936 | 646 s->mv_type = MV_TYPE_8X8; |
647 for(i=0; i<4; i++){ | |
3247 | 648 ff_mpeg4_set_one_direct_mv(s, mx, my, i); |
936 | 649 } |
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
|
650 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
|
651 } else if(IS_INTERLACED(colocated_mb_type)){ |
936 | 652 s->mv_type = MV_TYPE_FIELD; |
653 for(i=0; i<2; i++){ | |
1948 | 654 int field_select= s->next_picture.ref_index[0][s->block_index[2*i]]; |
3205 | 655 s->field_select[0][i]= field_select; |
656 s->field_select[1][i]= i; | |
936 | 657 if(s->top_field_first){ |
1948 | 658 time_pp= s->pp_field_time - field_select + i; |
659 time_pb= s->pb_field_time - field_select + i; | |
936 | 660 }else{ |
1948 | 661 time_pp= s->pp_field_time + field_select - i; |
662 time_pb= s->pb_field_time + field_select - i; | |
936 | 663 } |
1708 | 664 s->mv[0][i][0] = s->p_field_mv_table[i][0][mb_index][0]*time_pb/time_pp + mx; |
665 s->mv[0][i][1] = s->p_field_mv_table[i][0][mb_index][1]*time_pb/time_pp + my; | |
666 s->mv[1][i][0] = mx ? s->mv[0][i][0] - s->p_field_mv_table[i][0][mb_index][0] | |
667 : s->p_field_mv_table[i][0][mb_index][0]*(time_pb - time_pp)/time_pp; | |
2967 | 668 s->mv[1][i][1] = my ? s->mv[0][i][1] - s->p_field_mv_table[i][0][mb_index][1] |
1708 | 669 : s->p_field_mv_table[i][0][mb_index][1]*(time_pb - time_pp)/time_pp; |
936 | 670 } |
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
|
671 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
|
672 }else{ |
3247 | 673 ff_mpeg4_set_one_direct_mv(s, mx, my, 0); |
674 s->mv[0][1][0] = s->mv[0][2][0] = s->mv[0][3][0] = s->mv[0][0][0]; | |
675 s->mv[0][1][1] = s->mv[0][2][1] = s->mv[0][3][1] = s->mv[0][0][1]; | |
676 s->mv[1][1][0] = s->mv[1][2][0] = s->mv[1][3][0] = s->mv[1][0][0]; | |
677 s->mv[1][1][1] = s->mv[1][2][1] = s->mv[1][3][1] = s->mv[1][0][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
|
678 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
|
679 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
|
680 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
|
681 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
|
682 return MB_TYPE_DIRECT2 | MB_TYPE_16x16 | MB_TYPE_L0L1; //Note see prev line |
936 | 683 } |
684 } | |
685 | |
1389 | 686 void ff_h263_update_motion_val(MpegEncContext * s){ |
687 const int mb_xy = s->mb_y * s->mb_stride + s->mb_x; | |
2646
c735e3e60ca7
Even More spelling errors. patch by (Kevin Baragona <kevinmb500 gawab com)
michael
parents:
2639
diff
changeset
|
688 //FIXME a lot of that is only needed for !low_delay |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
689 const int wrap = s->b8_stride; |
1389 | 690 const int xy = s->block_index[0]; |
2967 | 691 |
692 s->current_picture.mbskip_table[mb_xy]= s->mb_skipped; | |
1389 | 693 |
694 if(s->mv_type != MV_TYPE_8X8){ | |
695 int motion_x, motion_y; | |
696 if (s->mb_intra) { | |
697 motion_x = 0; | |
698 motion_y = 0; | |
699 } else if (s->mv_type == MV_TYPE_16X16) { | |
700 motion_x = s->mv[0][0][0]; | |
701 motion_y = s->mv[0][0][1]; | |
702 } else /*if (s->mv_type == MV_TYPE_FIELD)*/ { | |
703 int i; | |
704 motion_x = s->mv[0][0][0] + s->mv[0][1][0]; | |
705 motion_y = s->mv[0][0][1] + s->mv[0][1][1]; | |
706 motion_x = (motion_x>>1) | (motion_x&1); | |
707 for(i=0; i<2; i++){ | |
1708 | 708 s->p_field_mv_table[i][0][mb_xy][0]= s->mv[0][i][0]; |
709 s->p_field_mv_table[i][0][mb_xy][1]= s->mv[0][i][1]; | |
1389 | 710 } |
1948 | 711 s->current_picture.ref_index[0][xy ]= |
712 s->current_picture.ref_index[0][xy + 1]= s->field_select[0][0]; | |
713 s->current_picture.ref_index[0][xy + wrap ]= | |
714 s->current_picture.ref_index[0][xy + wrap + 1]= s->field_select[0][1]; | |
1389 | 715 } |
1948 | 716 |
1389 | 717 /* 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
|
718 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
|
719 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
|
720 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
|
721 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
|
722 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
|
723 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
|
724 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
|
725 s->current_picture.motion_val[0][xy + 1 + wrap][1] = motion_y; |
1389 | 726 } |
727 | |
728 if(s->encoding){ //FIXME encoding MUST be cleaned up | |
2967 | 729 if (s->mv_type == MV_TYPE_8X8) |
1389 | 730 s->current_picture.mb_type[mb_xy]= MB_TYPE_L0 | MB_TYPE_8x8; |
1633 | 731 else if(s->mb_intra) |
732 s->current_picture.mb_type[mb_xy]= MB_TYPE_INTRA; | |
1389 | 733 else |
734 s->current_picture.mb_type[mb_xy]= MB_TYPE_L0 | MB_TYPE_16x16; | |
735 } | |
736 } | |
737 | |
8590 | 738 #if CONFIG_ENCODERS |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
739 |
2502 | 740 static inline int h263_get_motion_length(MpegEncContext * s, int val, int f_code){ |
741 int l, bit_size, code; | |
742 | |
743 if (val == 0) { | |
744 return mvtab[0][1]; | |
745 } else { | |
746 bit_size = f_code - 1; | |
747 /* modulo encoding */ | |
748 l= INT_BIT - 6 - bit_size; | |
749 val = (val<<l)>>l; | |
750 val--; | |
751 code = (val >> bit_size) + 1; | |
752 | |
753 return mvtab[code][1] + 1 + bit_size; | |
754 } | |
755 } | |
756 | |
757 static inline void ff_h263_encode_motion_vector(MpegEncContext * s, int x, int y, int f_code){ | |
758 if(s->flags2 & CODEC_FLAG2_NO_OUTPUT){ | |
2967 | 759 skip_put_bits(&s->pb, |
2502 | 760 h263_get_motion_length(s, x, f_code) |
761 +h263_get_motion_length(s, y, f_code)); | |
762 }else{ | |
763 ff_h263_encode_motion(s, x, f_code); | |
764 ff_h263_encode_motion(s, y, f_code); | |
765 } | |
766 } | |
767 | |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
768 static inline int get_p_cbp(MpegEncContext * s, |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
769 DCTELEM block[6][64], |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
770 int motion_x, int motion_y){ |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
771 int cbp, i; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
772 |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
773 if(s->flags & CODEC_FLAG_CBP_RD){ |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
774 int best_cbpy_score= INT_MAX; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
775 int best_cbpc_score= INT_MAX; |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
776 int cbpc = (-1), cbpy= (-1); |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
777 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
|
778 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
|
779 |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
780 for(i=0; i<4; i++){ |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
781 int score= inter_MCBPC_bits[i + offset] * lambda; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
782 if(i&1) score += s->coded_score[5]; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
783 if(i&2) score += s->coded_score[4]; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
784 |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
785 if(score < best_cbpc_score){ |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
786 best_cbpc_score= score; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
787 cbpc= i; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
788 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
789 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
790 |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
791 for(i=0; i<16; i++){ |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
792 int score= cbpy_tab[i ^ 0xF][1] * lambda; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
793 if(i&1) score += s->coded_score[3]; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
794 if(i&2) score += s->coded_score[2]; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
795 if(i&4) score += s->coded_score[1]; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
796 if(i&8) score += s->coded_score[0]; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
797 |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
798 if(score < best_cbpy_score){ |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
799 best_cbpy_score= score; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
800 cbpy= i; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
801 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
802 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
803 cbp= cbpc + 4*cbpy; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
804 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
|
805 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
|
806 cbp= 0; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
807 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
808 |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
809 for (i = 0; i < 6; i++) { |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
810 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
|
811 s->block_last_index[i]= -1; |
8288 | 812 s->dsp.clear_block(s->block[i]); |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
813 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
814 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
815 }else{ |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
816 cbp= 0; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
817 for (i = 0; i < 6; i++) { |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
818 if (s->block_last_index[i] >= 0) |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
819 cbp |= 1 << (5 - i); |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
820 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
821 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
822 return cbp; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
823 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
824 |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
825 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
|
826 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
|
827 int cbp=0, i; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
828 |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
829 if(s->flags & CODEC_FLAG_CBP_RD){ |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
830 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
|
831 const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6); |
2967 | 832 |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
833 for(i=0; i<6; i++){ |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
834 if(s->coded_score[i] < 0){ |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
835 score += s->coded_score[i]; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
836 cbp |= 1 << (5 - i); |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
837 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
838 } |
2967 | 839 |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
840 if(cbp){ |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
841 int zero_score= -6; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
842 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
|
843 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
|
844 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
845 |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
846 zero_score*= lambda; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
847 if(zero_score <= score){ |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
848 cbp=0; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
849 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
850 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
851 |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
852 for (i = 0; i < 6; i++) { |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
853 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
|
854 s->block_last_index[i]= -1; |
8288 | 855 s->dsp.clear_block(s->block[i]); |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
856 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
857 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
858 }else{ |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
859 for (i = 0; i < 6; i++) { |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
860 if (s->block_last_index[i] >= 0) |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
861 cbp |= 1 << (5 - i); |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
862 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
863 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
864 return cbp; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
865 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
866 |
2967 | 867 static inline void mpeg4_encode_blocks(MpegEncContext * s, DCTELEM block[6][64], int intra_dc[6], |
2502 | 868 uint8_t **scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb){ |
869 int i; | |
2967 | 870 |
2502 | 871 if(scan_table){ |
872 if(s->flags2 & CODEC_FLAG2_NO_OUTPUT){ | |
873 for (i = 0; i < 6; i++) { | |
874 skip_put_bits(&s->pb, mpeg4_get_block_length(s, block[i], i, intra_dc[i], scan_table[i])); | |
875 } | |
876 }else{ | |
877 /* encode each block */ | |
878 for (i = 0; i < 6; i++) { | |
879 mpeg4_encode_block(s, block[i], i, intra_dc[i], scan_table[i], dc_pb, ac_pb); | |
880 } | |
881 } | |
882 }else{ | |
883 if(s->flags2 & CODEC_FLAG2_NO_OUTPUT){ | |
884 for (i = 0; i < 6; i++) { | |
885 skip_put_bits(&s->pb, mpeg4_get_block_length(s, block[i], i, 0, s->intra_scantable.permutated)); | |
886 } | |
887 }else{ | |
888 /* encode each block */ | |
889 for (i = 0; i < 6; i++) { | |
890 mpeg4_encode_block(s, block[i], i, 0, s->intra_scantable.permutated, dc_pb, ac_pb); | |
891 } | |
892 } | |
893 } | |
894 } | |
895 | |
8644 | 896 static const int dquant_code[5]= {1,0,9,2,3}; |
897 | |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
898 void mpeg4_encode_mb(MpegEncContext * s, |
2979 | 899 DCTELEM block[6][64], |
900 int motion_x, int motion_y) | |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
901 { |
1057 | 902 int cbpc, cbpy, pred_x, pred_y; |
453 | 903 PutBitContext * const pb2 = s->data_partitioning ? &s->pb2 : &s->pb; |
6481 | 904 PutBitContext * const tex_pb = s->data_partitioning && s->pict_type!=FF_B_TYPE ? &s->tex_pb : &s->pb; |
905 PutBitContext * const dc_pb = s->data_partitioning && s->pict_type!=FF_I_TYPE ? &s->pb2 : &s->pb; | |
453 | 906 const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1) && !s->data_partitioning ? 1 : 0; |
2967 | 907 |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
908 // 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
|
909 if (!s->mb_intra) { |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
910 int i, cbp; |
2967 | 911 |
6481 | 912 if(s->pict_type==FF_B_TYPE){ |
5445
5581a40c673a
exchange the values of MV_DIR_FORWARD and MV_DIR_BACKWARD (this is more sane,
michael
parents:
5405
diff
changeset
|
913 static const int mb_type_table[8]= {-1, 3, 2, 1,-1,-1,-1, 0}; /* convert from mv_dir to type */ |
324 | 914 int mb_type= mb_type_table[s->mv_dir]; |
1708 | 915 |
324 | 916 if(s->mb_x==0){ |
1708 | 917 for(i=0; i<2; i++){ |
2967 | 918 s->last_mv[i][0][0]= |
919 s->last_mv[i][0][1]= | |
920 s->last_mv[i][1][0]= | |
1708 | 921 s->last_mv[i][1][1]= 0; |
922 } | |
324 | 923 } |
2967 | 924 |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
925 assert(s->dquant>=-2 && s->dquant<=2); |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
926 assert((s->dquant&1)==0); |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
927 assert(mb_type>=0); |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
928 |
2628
511e3afc43e1
Ministry of English Composition, reporting for duty (and the word is "skipped", not "skiped"; "skiped" would rhyme with "hyped")
melanson
parents:
2615
diff
changeset
|
929 /* nothing to do if this MB was skipped 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
|
930 if(s->next_picture.mbskip_table[s->mb_y * s->mb_stride + s->mb_x]){ //FIXME avoid DCT & ... |
324 | 931 s->skip_count++; |
2967 | 932 s->mv[0][0][0]= |
933 s->mv[0][0][1]= | |
934 s->mv[1][0][0]= | |
324 | 935 s->mv[1][0][1]= 0; |
2646
c735e3e60ca7
Even More spelling errors. patch by (Kevin Baragona <kevinmb500 gawab com)
michael
parents:
2639
diff
changeset
|
936 s->mv_dir= MV_DIR_FORWARD; //doesn't matter |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
937 s->qscale -= s->dquant; |
2628
511e3afc43e1
Ministry of English Composition, reporting for duty (and the word is "skipped", not "skiped"; "skiped" would rhyme with "hyped")
melanson
parents:
2615
diff
changeset
|
938 // s->mb_skipped=1; |
903 | 939 |
324 | 940 return; |
941 } | |
2967 | 942 |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
943 cbp= get_b_cbp(s, block, motion_x, motion_y, mb_type); |
2967 | 944 |
324 | 945 if ((cbp | motion_x | motion_y | mb_type) ==0) { |
946 /* direct MB with MV={0,0} */ | |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
947 assert(s->dquant==0); |
2967 | 948 |
324 | 949 put_bits(&s->pb, 1, 1); /* mb not coded modb1=1 */ |
453 | 950 |
951 if(interleaved_stats){ | |
952 s->misc_bits++; | |
953 s->last_bits++; | |
954 } | |
324 | 955 s->skip_count++; |
956 return; | |
957 } | |
2967 | 958 |
2979 | 959 put_bits(&s->pb, 1, 0); /* mb coded modb1=0 */ |
324 | 960 put_bits(&s->pb, 1, cbp ? 0 : 1); /* modb2 */ //FIXME merge |
2646
c735e3e60ca7
Even More spelling errors. patch by (Kevin Baragona <kevinmb500 gawab com)
michael
parents:
2639
diff
changeset
|
961 put_bits(&s->pb, mb_type+1, 1); // this table is so simple that we don't need it :) |
324 | 962 if(cbp) put_bits(&s->pb, 6, cbp); |
2967 | 963 |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
964 if(cbp && mb_type){ |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
965 if(s->dquant) |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
966 put_bits(&s->pb, 2, (s->dquant>>2)+3); |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
967 else |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
968 put_bits(&s->pb, 1, 0); |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
969 }else |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
970 s->qscale -= s->dquant; |
2967 | 971 |
697 | 972 if(!s->progressive_sequence){ |
973 if(cbp) | |
974 put_bits(&s->pb, 1, s->interlaced_dct); | |
2646
c735e3e60ca7
Even More spelling errors. patch by (Kevin Baragona <kevinmb500 gawab com)
michael
parents:
2639
diff
changeset
|
975 if(mb_type) // not direct mode |
1708 | 976 put_bits(&s->pb, 1, s->mv_type == MV_TYPE_FIELD); |
697 | 977 } |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
978 |
453 | 979 if(interleaved_stats){ |
1164 | 980 s->misc_bits+= get_bits_diff(s); |
453 | 981 } |
295 | 982 |
1708 | 983 if(mb_type == 0){ |
984 assert(s->mv_dir & MV_DIRECT); | |
2502 | 985 ff_h263_encode_motion_vector(s, motion_x, motion_y, 1); |
656
e47fa3e3f2d5
statistics for forw & back p-MBs instead of just one counter for both
michaelni
parents:
654
diff
changeset
|
986 s->b_count++; |
e47fa3e3f2d5
statistics for forw & back p-MBs instead of just one counter for both
michaelni
parents:
654
diff
changeset
|
987 s->f_count++; |
1708 | 988 }else{ |
989 assert(mb_type > 0 && mb_type < 4); | |
990 if(s->mv_type != MV_TYPE_FIELD){ | |
991 if(s->mv_dir & MV_DIR_FORWARD){ | |
2502 | 992 ff_h263_encode_motion_vector(s, s->mv[0][0][0] - s->last_mv[0][0][0], |
993 s->mv[0][0][1] - s->last_mv[0][0][1], s->f_code); | |
1708 | 994 s->last_mv[0][0][0]= s->last_mv[0][1][0]= s->mv[0][0][0]; |
995 s->last_mv[0][0][1]= s->last_mv[0][1][1]= s->mv[0][0][1]; | |
996 s->f_count++; | |
997 } | |
998 if(s->mv_dir & MV_DIR_BACKWARD){ | |
2502 | 999 ff_h263_encode_motion_vector(s, s->mv[1][0][0] - s->last_mv[1][0][0], |
1000 s->mv[1][0][1] - s->last_mv[1][0][1], s->b_code); | |
1708 | 1001 s->last_mv[1][0][0]= s->last_mv[1][1][0]= s->mv[1][0][0]; |
1002 s->last_mv[1][0][1]= s->last_mv[1][1][1]= s->mv[1][0][1]; | |
1003 s->b_count++; | |
1004 } | |
1005 }else{ | |
1006 if(s->mv_dir & MV_DIR_FORWARD){ | |
1007 put_bits(&s->pb, 1, s->field_select[0][0]); | |
1008 put_bits(&s->pb, 1, s->field_select[0][1]); | |
1009 } | |
1010 if(s->mv_dir & MV_DIR_BACKWARD){ | |
1011 put_bits(&s->pb, 1, s->field_select[1][0]); | |
1012 put_bits(&s->pb, 1, s->field_select[1][1]); | |
1013 } | |
1014 if(s->mv_dir & MV_DIR_FORWARD){ | |
1015 for(i=0; i<2; i++){ | |
2502 | 1016 ff_h263_encode_motion_vector(s, s->mv[0][i][0] - s->last_mv[0][i][0] , |
1017 s->mv[0][i][1] - s->last_mv[0][i][1]/2, s->f_code); | |
1708 | 1018 s->last_mv[0][i][0]= s->mv[0][i][0]; |
1019 s->last_mv[0][i][1]= s->mv[0][i][1]*2; | |
1020 } | |
1021 s->f_count++; | |
1022 } | |
1023 if(s->mv_dir & MV_DIR_BACKWARD){ | |
1024 for(i=0; i<2; i++){ | |
2502 | 1025 ff_h263_encode_motion_vector(s, s->mv[1][i][0] - s->last_mv[1][i][0] , |
1026 s->mv[1][i][1] - s->last_mv[1][i][1]/2, s->b_code); | |
1708 | 1027 s->last_mv[1][i][0]= s->mv[1][i][0]; |
1028 s->last_mv[1][i][1]= s->mv[1][i][1]*2; | |
1029 } | |
1030 s->b_count++; | |
1031 } | |
1032 } | |
324 | 1033 } |
453 | 1034 |
1035 if(interleaved_stats){ | |
1164 | 1036 s->mv_bits+= get_bits_diff(s); |
453 | 1037 } |
295 | 1038 |
2502 | 1039 mpeg4_encode_blocks(s, block, NULL, NULL, NULL, &s->pb); |
453 | 1040 |
1041 if(interleaved_stats){ | |
1164 | 1042 s->p_tex_bits+= get_bits_diff(s); |
453 | 1043 } |
1708 | 1044 |
6481 | 1045 }else{ /* s->pict_type==FF_B_TYPE */ |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
1046 cbp= get_p_cbp(s, block, motion_x, motion_y); |
2967 | 1047 |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
1048 if ((cbp | motion_x | motion_y | s->dquant) == 0 && s->mv_type==MV_TYPE_16X16) { |
2967 | 1049 /* check if the B frames can skip it too, as we must skip it if we skip here |
2646
c735e3e60ca7
Even More spelling errors. patch by (Kevin Baragona <kevinmb500 gawab com)
michael
parents:
2639
diff
changeset
|
1050 why didn't they just compress the skip-mb bits instead of reusing them ?! */ |
331 | 1051 if(s->max_b_frames>0){ |
1052 int i; | |
364
6b6332e7008a
segfault fix for b-frame encoding with height%16!=0
michaelni
parents:
360
diff
changeset
|
1053 int x,y, offset; |
6b6332e7008a
segfault fix for b-frame encoding with height%16!=0
michaelni
parents:
360
diff
changeset
|
1054 uint8_t *p_pic; |
6b6332e7008a
segfault fix for b-frame encoding with height%16!=0
michaelni
parents:
360
diff
changeset
|
1055 |
6b6332e7008a
segfault fix for b-frame encoding with height%16!=0
michaelni
parents:
360
diff
changeset
|
1056 x= s->mb_x*16; |
6b6332e7008a
segfault fix for b-frame encoding with height%16!=0
michaelni
parents:
360
diff
changeset
|
1057 y= s->mb_y*16; |
6b6332e7008a
segfault fix for b-frame encoding with height%16!=0
michaelni
parents:
360
diff
changeset
|
1058 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
|
1059 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
|
1060 |
6b6332e7008a
segfault fix for b-frame encoding with height%16!=0
michaelni
parents:
360
diff
changeset
|
1061 offset= x + y*s->linesize; |
903 | 1062 p_pic= s->new_picture.data[0] + offset; |
2967 | 1063 |
2628
511e3afc43e1
Ministry of English Composition, reporting for duty (and the word is "skipped", not "skiped"; "skiped" would rhyme with "hyped")
melanson
parents:
2615
diff
changeset
|
1064 s->mb_skipped=1; |
331 | 1065 for(i=0; i<s->max_b_frames; i++){ |
339 | 1066 uint8_t *b_pic; |
1067 int diff; | |
903 | 1068 Picture *pic= s->reordered_input_picture[i+1]; |
1069 | |
6481 | 1070 if(pic==NULL || pic->pict_type!=FF_B_TYPE) break; |
903 | 1071 |
3068 | 1072 b_pic= pic->data[0] + offset; |
1073 if(pic->type != FF_BUFFER_TYPE_SHARED) | |
1074 b_pic+= INPLACE_OFFSET; | |
2979 | 1075 diff= s->dsp.sad[0](NULL, p_pic, b_pic, s->linesize, 16); |
364
6b6332e7008a
segfault fix for b-frame encoding with height%16!=0
michaelni
parents:
360
diff
changeset
|
1076 if(diff>s->qscale*70){ //FIXME check that 70 is optimal |
2628
511e3afc43e1
Ministry of English Composition, reporting for duty (and the word is "skipped", not "skiped"; "skiped" would rhyme with "hyped")
melanson
parents:
2615
diff
changeset
|
1077 s->mb_skipped=0; |
331 | 1078 break; |
1079 } | |
1080 } | |
1081 }else | |
2967 | 1082 s->mb_skipped=1; |
2628
511e3afc43e1
Ministry of English Composition, reporting for duty (and the word is "skipped", not "skiped"; "skiped" would rhyme with "hyped")
melanson
parents:
2615
diff
changeset
|
1083 |
511e3afc43e1
Ministry of English Composition, reporting for duty (and the word is "skipped", not "skiped"; "skiped" would rhyme with "hyped")
melanson
parents:
2615
diff
changeset
|
1084 if(s->mb_skipped==1){ |
331 | 1085 /* skip macroblock */ |
1086 put_bits(&s->pb, 1, 1); | |
453 | 1087 |
1088 if(interleaved_stats){ | |
1089 s->misc_bits++; | |
1090 s->last_bits++; | |
1091 } | |
331 | 1092 s->skip_count++; |
2967 | 1093 |
331 | 1094 return; |
1095 } | |
295 | 1096 } |
364
6b6332e7008a
segfault fix for b-frame encoding with height%16!=0
michaelni
parents:
360
diff
changeset
|
1097 |
2979 | 1098 put_bits(&s->pb, 1, 0); /* mb coded */ |
1633 | 1099 cbpc = cbp & 3; |
1100 cbpy = cbp >> 2; | |
1101 cbpy ^= 0xf; | |
324 | 1102 if(s->mv_type==MV_TYPE_16X16){ |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
1103 if(s->dquant) cbpc+= 8; |
324 | 1104 put_bits(&s->pb, |
1105 inter_MCBPC_bits[cbpc], | |
1106 inter_MCBPC_code[cbpc]); | |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
1107 |
453 | 1108 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
|
1109 if(s->dquant) |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
1110 put_bits(pb2, 2, dquant_code[s->dquant+2]); |
697 | 1111 |
1112 if(!s->progressive_sequence){ | |
1113 if(cbp) | |
1114 put_bits(pb2, 1, s->interlaced_dct); | |
1708 | 1115 put_bits(pb2, 1, 0); |
697 | 1116 } |
2967 | 1117 |
453 | 1118 if(interleaved_stats){ |
1164 | 1119 s->misc_bits+= get_bits_diff(s); |
453 | 1120 } |
324 | 1121 |
1122 /* motion vectors: 16x16 mode */ | |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
1123 h263_pred_motion(s, 0, 0, &pred_x, &pred_y); |
2967 | 1124 |
2502 | 1125 ff_h263_encode_motion_vector(s, motion_x - pred_x, |
1126 motion_y - pred_y, s->f_code); | |
1708 | 1127 }else if(s->mv_type==MV_TYPE_FIELD){ |
1128 if(s->dquant) cbpc+= 8; | |
1129 put_bits(&s->pb, | |
1130 inter_MCBPC_bits[cbpc], | |
1131 inter_MCBPC_code[cbpc]); | |
1132 | |
1133 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]); | |
1134 if(s->dquant) | |
1135 put_bits(pb2, 2, dquant_code[s->dquant+2]); | |
1136 | |
1137 assert(!s->progressive_sequence); | |
1138 if(cbp) | |
1139 put_bits(pb2, 1, s->interlaced_dct); | |
1140 put_bits(pb2, 1, 1); | |
2967 | 1141 |
1708 | 1142 if(interleaved_stats){ |
1143 s->misc_bits+= get_bits_diff(s); | |
1144 } | |
1145 | |
1146 /* motion vectors: 16x8 interlaced mode */ | |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
1147 h263_pred_motion(s, 0, 0, &pred_x, &pred_y); |
1708 | 1148 pred_y /=2; |
2967 | 1149 |
1708 | 1150 put_bits(&s->pb, 1, s->field_select[0][0]); |
1151 put_bits(&s->pb, 1, s->field_select[0][1]); | |
2967 | 1152 |
2502 | 1153 ff_h263_encode_motion_vector(s, s->mv[0][0][0] - pred_x, |
1154 s->mv[0][0][1] - pred_y, s->f_code); | |
1155 ff_h263_encode_motion_vector(s, s->mv[0][1][0] - pred_x, | |
1156 s->mv[0][1][1] - pred_y, s->f_code); | |
324 | 1157 }else{ |
1708 | 1158 assert(s->mv_type==MV_TYPE_8X8); |
324 | 1159 put_bits(&s->pb, |
1633 | 1160 inter_MCBPC_bits[cbpc+16], |
1161 inter_MCBPC_code[cbpc+16]); | |
453 | 1162 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]); |
1163 | |
757 | 1164 if(!s->progressive_sequence){ |
1165 if(cbp) | |
1166 put_bits(pb2, 1, s->interlaced_dct); | |
1167 } | |
2967 | 1168 |
453 | 1169 if(interleaved_stats){ |
1164 | 1170 s->misc_bits+= get_bits_diff(s); |
453 | 1171 } |
324 | 1172 |
1173 for(i=0; i<4; i++){ | |
1174 /* motion vectors: 8x8 mode*/ | |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
1175 h263_pred_motion(s, i, 0, &pred_x, &pred_y); |
324 | 1176 |
2502 | 1177 ff_h263_encode_motion_vector(s, s->current_picture.motion_val[0][ s->block_index[i] ][0] - pred_x, |
1178 s->current_picture.motion_val[0][ s->block_index[i] ][1] - pred_y, s->f_code); | |
324 | 1179 } |
1180 } | |
453 | 1181 |
2967 | 1182 if(interleaved_stats){ |
1164 | 1183 s->mv_bits+= get_bits_diff(s); |
453 | 1184 } |
324 | 1185 |
2502 | 1186 mpeg4_encode_blocks(s, block, NULL, NULL, NULL, tex_pb); |
453 | 1187 |
1188 if(interleaved_stats){ | |
1164 | 1189 s->p_tex_bits+= get_bits_diff(s); |
453 | 1190 } |
656
e47fa3e3f2d5
statistics for forw & back p-MBs instead of just one counter for both
michaelni
parents:
654
diff
changeset
|
1191 s->f_count++; |
295 | 1192 } |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1193 } else { |
324 | 1194 int cbp; |
2967 | 1195 int dc_diff[6]; //dc values with the dc prediction subtracted |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1196 int dir[6]; //prediction direction |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1197 int zigzag_last_index[6]; |
2979 | 1198 uint8_t *scan_table[6]; |
1057 | 1199 int i; |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1200 |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1201 for(i=0; i<6; i++){ |
2003 | 1202 dc_diff[i]= ff_mpeg4_pred_dc(s, i, block[i][0], &dir[i], 1); |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1203 } |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1204 |
1492 | 1205 if(s->flags & CODEC_FLAG_AC_PRED){ |
1206 s->ac_pred= decide_ac_pred(s, block, dir, scan_table, zigzag_last_index); | |
1207 if(!s->ac_pred) | |
1208 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
|
1209 }else{ |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1210 for(i=0; i<6; i++) |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
702
diff
changeset
|
1211 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
|
1212 } |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1213 |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1214 /* compute cbp */ |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1215 cbp = 0; |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1216 for (i = 0; i < 6; i++) { |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1217 if (s->block_last_index[i] >= 1) |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1218 cbp |= 1 << (5 - i); |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1219 } |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1220 |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1221 cbpc = cbp & 3; |
6481 | 1222 if (s->pict_type == FF_I_TYPE) { |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
1223 if(s->dquant) cbpc+=4; |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1224 put_bits(&s->pb, |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1225 intra_MCBPC_bits[cbpc], |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1226 intra_MCBPC_code[cbpc]); |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1227 } else { |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
1228 if(s->dquant) cbpc+=8; |
2979 | 1229 put_bits(&s->pb, 1, 0); /* mb coded */ |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1230 put_bits(&s->pb, |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1231 inter_MCBPC_bits[cbpc + 4], |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1232 inter_MCBPC_code[cbpc + 4]); |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1233 } |
453 | 1234 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
|
1235 cbpy = cbp >> 2; |
453 | 1236 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
|
1237 if(s->dquant) |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
1238 put_bits(dc_pb, 2, dquant_code[s->dquant+2]); |
453 | 1239 |
697 | 1240 if(!s->progressive_sequence){ |
1241 put_bits(dc_pb, 1, s->interlaced_dct); | |
1242 } | |
1243 | |
453 | 1244 if(interleaved_stats){ |
1164 | 1245 s->misc_bits+= get_bits_diff(s); |
453 | 1246 } |
286 | 1247 |
2502 | 1248 mpeg4_encode_blocks(s, block, dc_diff, scan_table, dc_pb, tex_pb); |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1249 |
453 | 1250 if(interleaved_stats){ |
1164 | 1251 s->i_tex_bits+= get_bits_diff(s); |
453 | 1252 } |
286 | 1253 s->i_count++; |
1254 | |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1255 /* restore ac coeffs & last_index stuff if we messed them up with the prediction */ |
1492 | 1256 if(s->ac_pred) |
1257 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
|
1258 } |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1259 } |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1260 |
0 | 1261 void h263_encode_mb(MpegEncContext * s, |
2979 | 1262 DCTELEM block[6][64], |
1263 int motion_x, int motion_y) | |
0 | 1264 { |
1265 int cbpc, cbpy, i, cbp, pred_x, pred_y; | |
1064 | 1266 int16_t pred_dc; |
1267 int16_t rec_intradc[6]; | |
3781 | 1268 int16_t *dc_ptr[6]; |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1269 const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1); |
2967 | 1270 |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1271 //printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y); |
324 | 1272 if (!s->mb_intra) { |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1273 /* compute cbp */ |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
1274 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
|
1275 |
1789 | 1276 if ((cbp | motion_x | motion_y | s->dquant | (s->mv_type - MV_TYPE_16X16)) == 0) { |
324 | 1277 /* skip macroblock */ |
1278 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
|
1279 if(interleaved_stats){ |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1280 s->misc_bits++; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1281 s->last_bits++; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1282 } |
1757
3906ddbaffec
optimization & bugfix extracted from the 4k line diff between ffmpeg 0.4.7 and http://www.alicestreet.com/ffh263.html
michael
parents:
1752
diff
changeset
|
1283 s->skip_count++; |
3906ddbaffec
optimization & bugfix extracted from the 4k line diff between ffmpeg 0.4.7 and http://www.alicestreet.com/ffh263.html
michael
parents:
1752
diff
changeset
|
1284 |
324 | 1285 return; |
1286 } | |
2979 | 1287 put_bits(&s->pb, 1, 0); /* mb coded */ |
2967 | 1288 |
324 | 1289 cbpc = cbp & 3; |
1637 | 1290 cbpy = cbp >> 2; |
1291 if(s->alt_inter_vlc==0 || cbpc!=3) | |
1292 cbpy ^= 0xF; | |
695 | 1293 if(s->dquant) cbpc+= 8; |
1633 | 1294 if(s->mv_type==MV_TYPE_16X16){ |
1295 put_bits(&s->pb, | |
1296 inter_MCBPC_bits[cbpc], | |
1297 inter_MCBPC_code[cbpc]); | |
1298 | |
1299 put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]); | |
1300 if(s->dquant) | |
1301 put_bits(&s->pb, 2, dquant_code[s->dquant+2]); | |
2967 | 1302 |
1633 | 1303 if(interleaved_stats){ |
1304 s->misc_bits+= get_bits_diff(s); | |
1305 } | |
1306 | |
1307 /* motion vectors: 16x16 mode */ | |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
1308 h263_pred_motion(s, 0, 0, &pred_x, &pred_y); |
2967 | 1309 |
1310 if (!s->umvplus) { | |
2502 | 1311 ff_h263_encode_motion_vector(s, motion_x - pred_x, |
1312 motion_y - pred_y, 1); | |
1633 | 1313 } |
1314 else { | |
1315 h263p_encode_umotion(s, motion_x - pred_x); | |
1316 h263p_encode_umotion(s, motion_y - pred_y); | |
1317 if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1)) | |
1318 /* To prevent Start Code emulation */ | |
1319 put_bits(&s->pb,1,1); | |
1320 } | |
1321 }else{ | |
1322 put_bits(&s->pb, | |
1323 inter_MCBPC_bits[cbpc+16], | |
1324 inter_MCBPC_code[cbpc+16]); | |
1325 put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]); | |
1326 if(s->dquant) | |
1327 put_bits(&s->pb, 2, dquant_code[s->dquant+2]); | |
1328 | |
1329 if(interleaved_stats){ | |
1330 s->misc_bits+= get_bits_diff(s); | |
1331 } | |
1332 | |
1333 for(i=0; i<4; i++){ | |
1334 /* motion vectors: 8x8 mode*/ | |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
1335 h263_pred_motion(s, i, 0, &pred_x, &pred_y); |
1633 | 1336 |
1668
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1666
diff
changeset
|
1337 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
|
1338 motion_y= s->current_picture.motion_val[0][ s->block_index[i] ][1]; |
2967 | 1339 if (!s->umvplus) { |
2502 | 1340 ff_h263_encode_motion_vector(s, motion_x - pred_x, |
1341 motion_y - pred_y, 1); | |
1633 | 1342 } |
1343 else { | |
1344 h263p_encode_umotion(s, motion_x - pred_x); | |
1345 h263p_encode_umotion(s, motion_y - pred_y); | |
1346 if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1)) | |
1347 /* To prevent Start Code emulation */ | |
1348 put_bits(&s->pb,1,1); | |
1349 } | |
1350 } | |
324 | 1351 } |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1352 |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1353 if(interleaved_stats){ |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1354 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
|
1355 } |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1356 } else { |
1639 | 1357 assert(s->mb_intra); |
2967 | 1358 |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1359 cbp = 0; |
1666 | 1360 if (s->h263_aic) { |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1361 /* Predict DC */ |
1666 | 1362 for(i=0; i<6; i++) { |
1064 | 1363 int16_t level = block[i][0]; |
1666 | 1364 int scale; |
2967 | 1365 |
1666 | 1366 if(i<4) scale= s->y_dc_scale; |
1367 else scale= s->c_dc_scale; | |
1368 | |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1369 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
|
1370 level -= pred_dc; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1371 /* Quant */ |
1666 | 1372 if (level >= 0) |
1373 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
|
1374 else |
1666 | 1375 level = (level - (scale>>1))/scale; |
2967 | 1376 |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1377 /* AIC can change CBP */ |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1378 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
|
1379 s->block_last_index[i] = -1; |
1666 | 1380 |
1381 if(!s->modified_quant){ | |
1382 if (level < -127) | |
1383 level = -127; | |
1384 else if (level > 127) | |
1385 level = 127; | |
1386 } | |
1387 | |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1388 block[i][0] = level; |
2967 | 1389 /* Reconstruction */ |
1666 | 1390 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
|
1391 /* Oddify */ |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1392 rec_intradc[i] |= 1; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1393 //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
|
1394 // rec_intradc[i]++; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1395 /* Clipping */ |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1396 if (rec_intradc[i] < 0) |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1397 rec_intradc[i] = 0; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1398 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
|
1399 rec_intradc[i] = 2047; |
2967 | 1400 |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1401 /* Update AC/DC tables */ |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1402 *dc_ptr[i] = rec_intradc[i]; |
1666 | 1403 if (s->block_last_index[i] >= 0) |
1404 cbp |= 1 << (5 - i); | |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1405 } |
1666 | 1406 }else{ |
1407 for(i=0; i<6; i++) { | |
1408 /* compute cbp */ | |
1409 if (s->block_last_index[i] >= 1) | |
1410 cbp |= 1 << (5 - i); | |
1411 } | |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1412 } |
0 | 1413 |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1414 cbpc = cbp & 3; |
6481 | 1415 if (s->pict_type == FF_I_TYPE) { |
695 | 1416 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
|
1417 put_bits(&s->pb, |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1418 intra_MCBPC_bits[cbpc], |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1419 intra_MCBPC_code[cbpc]); |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1420 } else { |
695 | 1421 if(s->dquant) cbpc+=8; |
2979 | 1422 put_bits(&s->pb, 1, 0); /* mb coded */ |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1423 put_bits(&s->pb, |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1424 inter_MCBPC_bits[cbpc + 4], |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1425 inter_MCBPC_code[cbpc + 4]); |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1426 } |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1427 if (s->h263_aic) { |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1428 /* XXX: currently, we do not try to use ac prediction */ |
2979 | 1429 put_bits(&s->pb, 1, 0); /* no AC prediction */ |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1430 } |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1431 cbpy = cbp >> 2; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1432 put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]); |
695 | 1433 if(s->dquant) |
1434 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
|
1435 |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1436 if(interleaved_stats){ |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1437 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
|
1438 } |
0 | 1439 } |
1440 | |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1441 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
|
1442 /* encode each block */ |
1354 | 1443 h263_encode_block(s, block[i], i); |
2967 | 1444 |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1445 /* Update INTRADC for decoding */ |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1446 if (s->h263_aic && s->mb_intra) { |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1447 block[i][0] = rec_intradc[i]; |
2967 | 1448 |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1449 } |
0 | 1450 } |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1451 |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1452 if(interleaved_stats){ |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1453 if (!s->mb_intra) { |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1454 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
|
1455 s->f_count++; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1456 }else{ |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1457 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
|
1458 s->i_count++; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1459 } |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1460 } |
0 | 1461 } |
815
78accc54493b
put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents:
770
diff
changeset
|
1462 #endif |
0 | 1463 |
1656 | 1464 void ff_h263_loop_filter(MpegEncContext * s){ |
1644 | 1465 int qp_c; |
1466 const int linesize = s->linesize; | |
1467 const int uvlinesize= s->uvlinesize; | |
1468 const int xy = s->mb_y * s->mb_stride + s->mb_x; | |
1469 uint8_t *dest_y = s->dest[0]; | |
1470 uint8_t *dest_cb= s->dest[1]; | |
1471 uint8_t *dest_cr= s->dest[2]; | |
2967 | 1472 |
6481 | 1473 // if(s->pict_type==FF_B_TYPE && !s->readable) return; |
1644 | 1474 |
1475 /* | |
1476 Diag Top | |
1477 Left Center | |
1478 */ | |
1479 if(!IS_SKIP(s->current_picture.mb_type[xy])){ | |
1480 qp_c= s->qscale; | |
1481 s->dsp.h263_v_loop_filter(dest_y+8*linesize , linesize, qp_c); | |
1482 s->dsp.h263_v_loop_filter(dest_y+8*linesize+8, linesize, qp_c); | |
1483 }else | |
1484 qp_c= 0; | |
1485 | |
1486 if(s->mb_y){ | |
8297
20e0f0809b27
s/qp_t/qp_tt/ to avoid bad examples that could lead to issues with reserved
michael
parents:
8288
diff
changeset
|
1487 int qp_dt, qp_tt, qp_tc; |
1644 | 1488 |
1489 if(IS_SKIP(s->current_picture.mb_type[xy-s->mb_stride])) | |
8297
20e0f0809b27
s/qp_t/qp_tt/ to avoid bad examples that could lead to issues with reserved
michael
parents:
8288
diff
changeset
|
1490 qp_tt=0; |
2967 | 1491 else |
8297
20e0f0809b27
s/qp_t/qp_tt/ to avoid bad examples that could lead to issues with reserved
michael
parents:
8288
diff
changeset
|
1492 qp_tt= s->current_picture.qscale_table[xy-s->mb_stride]; |
1644 | 1493 |
2967 | 1494 if(qp_c) |
1644 | 1495 qp_tc= qp_c; |
1496 else | |
8297
20e0f0809b27
s/qp_t/qp_tt/ to avoid bad examples that could lead to issues with reserved
michael
parents:
8288
diff
changeset
|
1497 qp_tc= qp_tt; |
2967 | 1498 |
1644 | 1499 if(qp_tc){ |
1500 const int chroma_qp= s->chroma_qscale_table[qp_tc]; | |
1501 s->dsp.h263_v_loop_filter(dest_y , linesize, qp_tc); | |
1502 s->dsp.h263_v_loop_filter(dest_y+8, linesize, qp_tc); | |
2967 | 1503 |
1644 | 1504 s->dsp.h263_v_loop_filter(dest_cb , uvlinesize, chroma_qp); |
1505 s->dsp.h263_v_loop_filter(dest_cr , uvlinesize, chroma_qp); | |
1506 } | |
2967 | 1507 |
8297
20e0f0809b27
s/qp_t/qp_tt/ to avoid bad examples that could lead to issues with reserved
michael
parents:
8288
diff
changeset
|
1508 if(qp_tt) |
20e0f0809b27
s/qp_t/qp_tt/ to avoid bad examples that could lead to issues with reserved
michael
parents:
8288
diff
changeset
|
1509 s->dsp.h263_h_loop_filter(dest_y-8*linesize+8 , linesize, qp_tt); |
2967 | 1510 |
1644 | 1511 if(s->mb_x){ |
8297
20e0f0809b27
s/qp_t/qp_tt/ to avoid bad examples that could lead to issues with reserved
michael
parents:
8288
diff
changeset
|
1512 if(qp_tt || IS_SKIP(s->current_picture.mb_type[xy-1-s->mb_stride])) |
20e0f0809b27
s/qp_t/qp_tt/ to avoid bad examples that could lead to issues with reserved
michael
parents:
8288
diff
changeset
|
1513 qp_dt= qp_tt; |
1644 | 1514 else |
1515 qp_dt= s->current_picture.qscale_table[xy-1-s->mb_stride]; | |
2967 | 1516 |
1644 | 1517 if(qp_dt){ |
1518 const int chroma_qp= s->chroma_qscale_table[qp_dt]; | |
1519 s->dsp.h263_h_loop_filter(dest_y -8*linesize , linesize, qp_dt); | |
1520 s->dsp.h263_h_loop_filter(dest_cb-8*uvlinesize, uvlinesize, chroma_qp); | |
2178 | 1521 s->dsp.h263_h_loop_filter(dest_cr-8*uvlinesize, uvlinesize, chroma_qp); |
1644 | 1522 } |
1523 } | |
1524 } | |
1525 | |
1526 if(qp_c){ | |
1527 s->dsp.h263_h_loop_filter(dest_y +8, linesize, qp_c); | |
1528 if(s->mb_y + 1 == s->mb_height) | |
1529 s->dsp.h263_h_loop_filter(dest_y+8*linesize+8, linesize, qp_c); | |
1530 } | |
2967 | 1531 |
1644 | 1532 if(s->mb_x){ |
1533 int qp_lc; | |
1534 if(qp_c || IS_SKIP(s->current_picture.mb_type[xy-1])) | |
1535 qp_lc= qp_c; | |
1536 else | |
1537 qp_lc= s->current_picture.qscale_table[xy-1]; | |
2967 | 1538 |
1644 | 1539 if(qp_lc){ |
1540 s->dsp.h263_h_loop_filter(dest_y, linesize, qp_lc); | |
1541 if(s->mb_y + 1 == s->mb_height){ | |
1542 const int chroma_qp= s->chroma_qscale_table[qp_lc]; | |
1543 s->dsp.h263_h_loop_filter(dest_y +8* linesize, linesize, qp_lc); | |
1544 s->dsp.h263_h_loop_filter(dest_cb , uvlinesize, chroma_qp); | |
1545 s->dsp.h263_h_loop_filter(dest_cr , uvlinesize, chroma_qp); | |
1546 } | |
1547 } | |
1548 } | |
1549 } | |
1550 | |
8590 | 1551 #if CONFIG_ENCODERS |
3781 | 1552 static int h263_pred_dc(MpegEncContext * s, int n, int16_t **dc_val_ptr) |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1553 { |
9481
44ea854a14b7
Remove several useless writes to variables, found by CSA.
michael
parents:
9465
diff
changeset
|
1554 int x, y, wrap, a, c, pred_dc; |
3781 | 1555 int16_t *dc_val; |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1556 |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1557 /* find prediction */ |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1558 if (n < 4) { |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
1559 x = 2 * s->mb_x + (n & 1); |
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
1560 y = 2 * s->mb_y + ((n & 2) >> 1); |
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
1561 wrap = s->b8_stride; |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1562 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
|
1563 } else { |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
1564 x = s->mb_x; |
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
1565 y = s->mb_y; |
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
1566 wrap = s->mb_stride; |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1567 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
|
1568 } |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1569 /* B C |
2967 | 1570 * A X |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1571 */ |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1572 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
|
1573 c = dc_val[(x) + (y - 1) * wrap]; |
2967 | 1574 |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1575 /* No prediction outside GOB boundary */ |
1896
ef87d53ca87a
h.263 ssm + aic fix by (Maarten Daniels <maarten dot daniels at student dot luc dot ac dot be>)
michael
parents:
1893
diff
changeset
|
1576 if(s->first_slice_line && n!=3){ |
ef87d53ca87a
h.263 ssm + aic fix by (Maarten Daniels <maarten dot daniels at student dot luc dot ac dot be>)
michael
parents:
1893
diff
changeset
|
1577 if(n!=2) c= 1024; |
ef87d53ca87a
h.263 ssm + aic fix by (Maarten Daniels <maarten dot daniels at student dot luc dot ac dot be>)
michael
parents:
1893
diff
changeset
|
1578 if(n!=1 && s->mb_x == s->resync_mb_x) a= 1024; |
ef87d53ca87a
h.263 ssm + aic fix by (Maarten Daniels <maarten dot daniels at student dot luc dot ac dot be>)
michael
parents:
1893
diff
changeset
|
1579 } |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1580 /* just DC prediction */ |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1581 if (a != 1024 && c != 1024) |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1582 pred_dc = (a + c) >> 1; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1583 else if (a != 1024) |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1584 pred_dc = a; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1585 else |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1586 pred_dc = c; |
2967 | 1587 |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1588 /* we assume pred is positive */ |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1589 *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
|
1590 return pred_dc; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1591 } |
3777 | 1592 #endif /* CONFIG_ENCODERS */ |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1593 |
1057 | 1594 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
|
1595 { |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1596 int x, y, wrap, a, c, pred_dc, scale, i; |
3781 | 1597 int16_t *dc_val, *ac_val, *ac_val1; |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1598 |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1599 /* find prediction */ |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1600 if (n < 4) { |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
1601 x = 2 * s->mb_x + (n & 1); |
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
1602 y = 2 * s->mb_y + (n>> 1); |
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
1603 wrap = s->b8_stride; |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1604 dc_val = s->dc_val[0]; |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1605 ac_val = s->ac_val[0][0]; |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1606 scale = s->y_dc_scale; |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1607 } else { |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
1608 x = s->mb_x; |
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
1609 y = s->mb_y; |
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
1610 wrap = s->mb_stride; |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1611 dc_val = s->dc_val[n - 4 + 1]; |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1612 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
|
1613 scale = s->c_dc_scale; |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1614 } |
2967 | 1615 |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1616 ac_val += ((y) * wrap + (x)) * 16; |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1617 ac_val1 = ac_val; |
2967 | 1618 |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1619 /* B C |
2967 | 1620 * A X |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1621 */ |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1622 a = dc_val[(x - 1) + (y) * wrap]; |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1623 c = dc_val[(x) + (y - 1) * wrap]; |
2967 | 1624 |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1625 /* No prediction outside GOB boundary */ |
1639 | 1626 if(s->first_slice_line && n!=3){ |
1627 if(n!=2) c= 1024; | |
1628 if(n!=1 && s->mb_x == s->resync_mb_x) a= 1024; | |
1629 } | |
2967 | 1630 |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1631 if (s->ac_pred) { |
1639 | 1632 pred_dc = 1024; |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1633 if (s->h263_aic_dir) { |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1634 /* left prediction */ |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1635 if (a != 1024) { |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1636 ac_val -= 16; |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1637 for(i=1;i<8;i++) { |
1092 | 1638 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
|
1639 } |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1640 pred_dc = a; |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1641 } |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1642 } else { |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1643 /* top prediction */ |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1644 if (c != 1024) { |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1645 ac_val -= 16 * wrap; |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1646 for(i=1;i<8;i++) { |
1092 | 1647 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
|
1648 } |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1649 pred_dc = c; |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1650 } |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1651 } |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1652 } else { |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1653 /* just DC prediction */ |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1654 if (a != 1024 && c != 1024) |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1655 pred_dc = (a + c) >> 1; |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1656 else if (a != 1024) |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1657 pred_dc = a; |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1658 else |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1659 pred_dc = c; |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1660 } |
2967 | 1661 |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1662 /* we assume pred is positive */ |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1663 block[0]=block[0]*scale + pred_dc; |
2967 | 1664 |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1665 if (block[0] < 0) |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1666 block[0] = 0; |
2967 | 1667 else |
1639 | 1668 block[0] |= 1; |
2967 | 1669 |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1670 /* Update AC/DC tables */ |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1671 dc_val[(x) + (y) * wrap] = block[0]; |
2967 | 1672 |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1673 /* left copy */ |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1674 for(i=1;i<8;i++) |
1092 | 1675 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
|
1676 /* top copy */ |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1677 for(i=1;i<8;i++) |
1092 | 1678 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
|
1679 } |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1680 |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
1681 int16_t *h263_pred_motion(MpegEncContext * s, int block, int dir, |
0 | 1682 int *px, int *py) |
1683 { | |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
1684 int wrap; |
1655 | 1685 int16_t *A, *B, *C, (*mot_val)[2]; |
1686 static const int off[4]= {2, 1, 1, -1}; | |
1687 | |
1688 wrap = s->b8_stride; | |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
1689 mot_val = s->current_picture.motion_val[dir] + s->block_index[block]; |
1655 | 1690 |
1691 A = mot_val[ - 1]; | |
1692 /* special case for first (slice) line */ | |
1693 if (s->first_slice_line && block<3) { | |
2646
c735e3e60ca7
Even More spelling errors. patch by (Kevin Baragona <kevinmb500 gawab com)
michael
parents:
2639
diff
changeset
|
1694 // we can't just change some MVs to simulate that as we need them for the B frames (and ME) |
1655 | 1695 // and if we ever support non rectangular objects than we need to do a few ifs here anyway :( |
1696 if(block==0){ //most common case | |
1697 if(s->mb_x == s->resync_mb_x){ //rare | |
1698 *px= *py = 0; | |
1699 }else if(s->mb_x + 1 == s->resync_mb_x && s->h263_pred){ //rare | |
1700 C = mot_val[off[block] - wrap]; | |
1701 if(s->mb_x==0){ | |
1702 *px = C[0]; | |
1703 *py = C[1]; | |
1704 }else{ | |
1705 *px = mid_pred(A[0], 0, C[0]); | |
1706 *py = mid_pred(A[1], 0, C[1]); | |
1707 } | |
1708 }else{ | |
1709 *px = A[0]; | |
1710 *py = A[1]; | |
1711 } | |
1712 }else if(block==1){ | |
1713 if(s->mb_x + 1 == s->resync_mb_x && s->h263_pred){ //rare | |
1714 C = mot_val[off[block] - wrap]; | |
1715 *px = mid_pred(A[0], 0, C[0]); | |
1716 *py = mid_pred(A[1], 0, C[1]); | |
1717 }else{ | |
1718 *px = A[0]; | |
1719 *py = A[1]; | |
1720 } | |
1721 }else{ /* block==2*/ | |
1722 B = mot_val[ - wrap]; | |
1723 C = mot_val[off[block] - wrap]; | |
1724 if(s->mb_x == s->resync_mb_x) //rare | |
1725 A[0]=A[1]=0; | |
2967 | 1726 |
1655 | 1727 *px = mid_pred(A[0], B[0], C[0]); |
1728 *py = mid_pred(A[1], B[1], C[1]); | |
1729 } | |
1730 } else { | |
1731 B = mot_val[ - wrap]; | |
1732 C = mot_val[off[block] - wrap]; | |
1733 *px = mid_pred(A[0], B[0], C[0]); | |
1734 *py = mid_pred(A[1], B[1], C[1]); | |
1735 } | |
1736 return *mot_val; | |
1737 } | |
1738 | |
8590 | 1739 #if CONFIG_ENCODERS |
2017 | 1740 void ff_h263_encode_motion(MpegEncContext * s, int val, int f_code) |
0 | 1741 { |
702 | 1742 int range, l, bit_size, sign, code, bits; |
0 | 1743 |
1744 if (val == 0) { | |
1745 /* zero vector */ | |
1746 code = 0; | |
1747 put_bits(&s->pb, mvtab[code][1], mvtab[code][0]); | |
1748 } else { | |
324 | 1749 bit_size = f_code - 1; |
0 | 1750 range = 1 << bit_size; |
1751 /* modulo encoding */ | |
2093 | 1752 l= INT_BIT - 6 - bit_size; |
1753 val = (val<<l)>>l; | |
702 | 1754 sign = val>>31; |
1755 val= (val^sign)-sign; | |
1756 sign&=1; | |
2093 | 1757 |
312 | 1758 val--; |
1759 code = (val >> bit_size) + 1; | |
1760 bits = val & (range - 1); | |
0 | 1761 |
2967 | 1762 put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign); |
0 | 1763 if (bit_size > 0) { |
1764 put_bits(&s->pb, bit_size, bits); | |
1765 } | |
1766 } | |
1767 } | |
1768 | |
78 | 1769 /* Encode MV differences on H.263+ with Unrestricted MV mode */ |
1770 static void h263p_encode_umotion(MpegEncContext * s, int val) | |
1771 { | |
2967 | 1772 short sval = 0; |
78 | 1773 short i = 0; |
1774 short n_bits = 0; | |
1775 short temp_val; | |
1776 int code = 0; | |
1777 int tcode; | |
2967 | 1778 |
78 | 1779 if ( val == 0) |
1780 put_bits(&s->pb, 1, 1); | |
1781 else if (val == 1) | |
1782 put_bits(&s->pb, 3, 0); | |
1783 else if (val == -1) | |
1784 put_bits(&s->pb, 3, 2); | |
1785 else { | |
2967 | 1786 |
78 | 1787 sval = ((val < 0) ? (short)(-val):(short)val); |
1788 temp_val = sval; | |
2967 | 1789 |
78 | 1790 while (temp_val != 0) { |
1791 temp_val = temp_val >> 1; | |
1792 n_bits++; | |
1793 } | |
2967 | 1794 |
78 | 1795 i = n_bits - 1; |
1796 while (i > 0) { | |
1797 tcode = (sval & (1 << (i-1))) >> (i-1); | |
1798 tcode = (tcode << 1) | 1; | |
1799 code = (code << 2) | tcode; | |
1800 i--; | |
1801 } | |
1802 code = ((code << 1) | (val < 0)) << 1; | |
1803 put_bits(&s->pb, (2*n_bits)+1, code); | |
1804 //printf("\nVal = %d\tCode = %d", sval, code); | |
1805 } | |
1806 } | |
1807 | |
277
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1808 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
|
1809 { |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1810 int f_code; |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1811 int mv; |
2967 | 1812 |
277
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1813 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
|
1814 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
|
1815 int len; |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1816 |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1817 if(mv==0) len= mvtab[0][1]; |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1818 else{ |
9465
9dcb191f1df3
Remove unused variable in init_mv_penalty_and_fcode() found by CSA.
michael
parents:
9458
diff
changeset
|
1819 int val, bit_size, code; |
277
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1820 |
1893
779bdf5063ce
1000000l (using uninitalized variable for initalizing bits per MV table)
michael
parents:
1873
diff
changeset
|
1821 bit_size = f_code - 1; |
277
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1822 |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1823 val=mv; |
2967 | 1824 if (val < 0) |
277
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1825 val = -val; |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1826 val--; |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1827 code = (val >> bit_size) + 1; |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1828 if(code<33){ |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1829 len= mvtab[code][1] + 1 + bit_size; |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1830 }else{ |
2985 | 1831 len= mvtab[32][1] + av_log2(code>>5) + 2 + bit_size; |
277
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1832 } |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1833 } |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1834 |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1835 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
|
1836 } |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1837 } |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1838 |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1839 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
|
1840 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
|
1841 fcode_tab[mv+MAX_MV]= f_code; |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1842 } |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1843 } |
287 | 1844 |
1845 for(mv=0; mv<MAX_MV*2+1; mv++){ | |
1846 umv_fcode_tab[mv]= 1; | |
1847 } | |
277
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1848 } |
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
|
1849 |
468 | 1850 static void init_uni_dc_tab(void) |
293 | 1851 { |
1852 int level, uni_code, uni_len; | |
1853 | |
312 | 1854 for(level=-256; level<256; level++){ |
293 | 1855 int size, v, l; |
1856 /* find number of bits */ | |
1857 size = 0; | |
1858 v = abs(level); | |
1859 while (v) { | |
1860 v >>= 1; | |
2979 | 1861 size++; |
293 | 1862 } |
1863 | |
1864 if (level < 0) | |
1865 l= (-level) ^ ((1 << size) - 1); | |
1866 else | |
1867 l= level; | |
1868 | |
1869 /* luminance */ | |
1870 uni_code= DCtab_lum[size][0]; | |
1871 uni_len = DCtab_lum[size][1]; | |
1872 | |
1873 if (size > 0) { | |
1874 uni_code<<=size; uni_code|=l; | |
1875 uni_len+=size; | |
1876 if (size > 8){ | |
1877 uni_code<<=1; uni_code|=1; | |
1878 uni_len++; | |
1879 } | |
1880 } | |
1013 | 1881 uni_DCtab_lum_bits[level+256]= uni_code; |
1882 uni_DCtab_lum_len [level+256]= uni_len; | |
293 | 1883 |
1884 /* chrominance */ | |
1885 uni_code= DCtab_chrom[size][0]; | |
1886 uni_len = DCtab_chrom[size][1]; | |
2967 | 1887 |
293 | 1888 if (size > 0) { |
1889 uni_code<<=size; uni_code|=l; | |
1890 uni_len+=size; | |
1891 if (size > 8){ | |
1892 uni_code<<=1; uni_code|=1; | |
1893 uni_len++; | |
1894 } | |
1895 } | |
1013 | 1896 uni_DCtab_chrom_bits[level+256]= uni_code; |
1897 uni_DCtab_chrom_len [level+256]= uni_len; | |
293 | 1898 |
1899 } | |
1900 } | |
1901 | |
1064 | 1902 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
|
1903 int slevel, run, last; |
2967 | 1904 |
648
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1905 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
|
1906 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
|
1907 |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1908 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
|
1909 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
|
1910 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
|
1911 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
|
1912 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
|
1913 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
|
1914 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
|
1915 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
|
1916 int level1, run1; |
2967 | 1917 |
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
|
1918 len_tab[index]= 100; |
2967 | 1919 |
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
|
1920 /* 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
|
1921 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
|
1922 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
|
1923 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
|
1924 bits=bits*2+sign; len++; |
2967 | 1925 |
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
|
1926 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
|
1927 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
|
1928 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
|
1929 } |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1930 #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
|
1931 /* 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
|
1932 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
|
1933 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
|
1934 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
|
1935 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
|
1936 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
|
1937 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
|
1938 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
|
1939 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
|
1940 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
|
1941 bits=bits*2+sign; len++; |
2967 | 1942 |
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
|
1943 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
|
1944 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
|
1945 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
|
1946 } |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1947 } |
2967 | 1948 #endif |
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
|
1949 #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
|
1950 /* 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
|
1951 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
|
1952 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
|
1953 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
|
1954 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
|
1955 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
|
1956 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
|
1957 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
|
1958 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
|
1959 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
|
1960 bits=bits*2+sign; len++; |
2967 | 1961 |
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
|
1962 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
|
1963 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
|
1964 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
|
1965 } |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1966 } |
2967 | 1967 #endif |
1968 /* ESC3 */ | |
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
|
1969 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
|
1970 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
|
1971 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
|
1972 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
|
1973 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
|
1974 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
|
1975 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
|
1976 bits=bits*2+1; len++; //marker |
2967 | 1977 |
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
|
1978 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
|
1979 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
|
1980 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
|
1981 } |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1982 } |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1983 } |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1984 } |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1985 } |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1986 |
2253 | 1987 static void init_uni_h263_rl_tab(RLTable *rl, uint32_t *bits_tab, uint8_t *len_tab){ |
1988 int slevel, run, last; | |
2967 | 1989 |
2253 | 1990 assert(MAX_LEVEL >= 64); |
1991 assert(MAX_RUN >= 63); | |
1992 | |
1993 for(slevel=-64; slevel<64; slevel++){ | |
1994 if(slevel==0) continue; | |
1995 for(run=0; run<64; run++){ | |
1996 for(last=0; last<=1; last++){ | |
1997 const int index= UNI_MPEG4_ENC_INDEX(last, run, slevel+64); | |
1998 int level= slevel < 0 ? -slevel : slevel; | |
1999 int sign= slevel < 0 ? 1 : 0; | |
2000 int bits, len, code; | |
2967 | 2001 |
2253 | 2002 len_tab[index]= 100; |
2967 | 2003 |
2253 | 2004 /* ESC0 */ |
2005 code= get_rl_index(rl, last, run, level); | |
2006 bits= rl->table_vlc[code][0]; | |
2007 len= rl->table_vlc[code][1]; | |
2008 bits=bits*2+sign; len++; | |
2967 | 2009 |
2253 | 2010 if(code!=rl->n && len < len_tab[index]){ |
2011 if(bits_tab) bits_tab[index]= bits; | |
2012 len_tab [index]= len; | |
2013 } | |
2014 /* ESC */ | |
2015 bits= rl->table_vlc[rl->n][0]; | |
2016 len = rl->table_vlc[rl->n][1]; | |
2017 bits=bits*2+last; len++; | |
2018 bits=bits*64+run; len+=6; | |
2019 bits=bits*256+(level&0xff); len+=8; | |
2967 | 2020 |
2253 | 2021 if(len < len_tab[index]){ |
2022 if(bits_tab) bits_tab[index]= bits; | |
2023 len_tab [index]= len; | |
2024 } | |
2025 } | |
2026 } | |
2027 } | |
2028 } | |
2029 | |
277
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
2030 void h263_encode_init(MpegEncContext *s) |
0 | 2031 { |
2032 static int done = 0; | |
2033 | |
2034 if (!done) { | |
2035 done = 1; | |
293 | 2036 |
2037 init_uni_dc_tab(); | |
2038 | |
4668 | 2039 init_rl(&rl_inter, static_rl_table_store[0]); |
2040 init_rl(&rl_intra, static_rl_table_store[1]); | |
2041 init_rl(&rl_intra_aic, static_rl_table_store[2]); | |
2967 | 2042 |
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
|
2043 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
|
2044 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
|
2045 |
2253 | 2046 init_uni_h263_rl_tab(&rl_intra_aic, NULL, uni_h263_intra_aic_rl_len); |
2047 init_uni_h263_rl_tab(&rl_inter , NULL, uni_h263_inter_rl_len); | |
2048 | |
277
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
2049 init_mv_penalty_and_fcode(s); |
0 | 2050 } |
936 | 2051 s->me.mv_penalty= mv_penalty; //FIXME exact table for msmpeg4 & h263p |
2967 | 2052 |
2253 | 2053 s->intra_ac_vlc_length =s->inter_ac_vlc_length = uni_h263_inter_rl_len; |
2054 s->intra_ac_vlc_last_length=s->inter_ac_vlc_last_length= uni_h263_inter_rl_len + 128*64; | |
2055 if(s->h263_aic){ | |
2056 s->intra_ac_vlc_length = uni_h263_intra_aic_rl_len; | |
2057 s->intra_ac_vlc_last_length= uni_h263_intra_aic_rl_len + 128*64; | |
2058 } | |
2059 s->ac_esc_length= 7+1+6+8; | |
2060 | |
287 | 2061 // use fcodes >1 only for mpeg4 & h263 & h263p FIXME |
344 | 2062 switch(s->codec_id){ |
2063 case CODEC_ID_MPEG4: | |
2064 s->fcode_tab= fcode_tab; | |
2065 s->min_qcoeff= -2048; | |
2066 s->max_qcoeff= 2047; | |
945 | 2067 s->intra_ac_vlc_length = uni_mpeg4_intra_rl_len; |
2068 s->intra_ac_vlc_last_length= uni_mpeg4_intra_rl_len + 128*64; | |
2069 s->inter_ac_vlc_length = uni_mpeg4_inter_rl_len; | |
2070 s->inter_ac_vlc_last_length= uni_mpeg4_inter_rl_len + 128*64; | |
1013 | 2071 s->luma_dc_vlc_length= uni_DCtab_lum_len; |
2072 s->chroma_dc_vlc_length= uni_DCtab_chrom_len; | |
945 | 2073 s->ac_esc_length= 7+2+1+6+1+12+1; |
1799 | 2074 s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table; |
2075 s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table; | |
2076 | |
1424 | 2077 if(s->flags & CODEC_FLAG_GLOBAL_HEADER){ |
1483 | 2078 |
1424 | 2079 s->avctx->extradata= av_malloc(1024); |
1522
79dddc5cd990
removed the obsolete and unused parameters of init_put_bits
alex
parents:
1521
diff
changeset
|
2080 init_put_bits(&s->pb, s->avctx->extradata, 1024); |
2967 | 2081 |
2572
c22ad129a91b
support omiting various headers in mpeg4 as WMP seems to have difficulty with them
michael
parents:
2554
diff
changeset
|
2082 if(!(s->workaround_bugs & FF_BUG_MS)) |
c22ad129a91b
support omiting various headers in mpeg4 as WMP seems to have difficulty with them
michael
parents:
2554
diff
changeset
|
2083 mpeg4_encode_visual_object_header(s); |
1424 | 2084 mpeg4_encode_vol_header(s, 0, 0); |
2085 | |
2086 // ff_mpeg4_stuffing(&s->pb); ? | |
2087 flush_put_bits(&s->pb); | |
1786 | 2088 s->avctx->extradata_size= (put_bits_count(&s->pb)+7)>>3; |
1424 | 2089 } |
2967 | 2090 |
344 | 2091 break; |
2092 case CODEC_ID_H263P: | |
1666 | 2093 if(s->umvplus) |
2094 s->fcode_tab= umv_fcode_tab; | |
2095 if(s->modified_quant){ | |
2096 s->min_qcoeff= -2047; | |
2097 s->max_qcoeff= 2047; | |
2098 }else{ | |
2099 s->min_qcoeff= -127; | |
2100 s->max_qcoeff= 127; | |
2101 } | |
344 | 2102 break; |
2967 | 2103 //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
|
2104 case CODEC_ID_FLV1: |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
2105 if (s->h263_flv > 1) { |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
2106 s->min_qcoeff= -1023; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
2107 s->max_qcoeff= 1023; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
2108 } else { |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
2109 s->min_qcoeff= -127; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
2110 s->max_qcoeff= 127; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
2111 } |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
2112 s->y_dc_scale_table= |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
2113 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
|
2114 break; |
2646
c735e3e60ca7
Even More spelling errors. patch by (Kevin Baragona <kevinmb500 gawab com)
michael
parents:
2639
diff
changeset
|
2115 default: //nothing needed - default table already set in mpegvideo.c |
1089 | 2116 s->min_qcoeff= -127; |
344 | 2117 s->max_qcoeff= 127; |
498 | 2118 s->y_dc_scale_table= |
2119 s->c_dc_scale_table= ff_mpeg1_dc_scale_table; | |
344 | 2120 } |
0 | 2121 } |
2122 | |
1034 | 2123 /** |
2124 * encodes a 8x8 block. | |
2125 * @param block the 8x8 block | |
2126 * @param n block index (0-3 are luma, 4-5 are chroma) | |
2127 */ | |
0 | 2128 static void h263_encode_block(MpegEncContext * s, DCTELEM * block, int n) |
2129 { | |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
2130 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
|
2131 RLTable *rl; |
0 | 2132 |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
2133 rl = &rl_inter; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
2134 if (s->mb_intra && !s->h263_aic) { |
231 | 2135 /* DC coef */ |
1089 | 2136 level = block[0]; |
0 | 2137 /* 255 cannot be represented, so we clamp */ |
2138 if (level > 254) { | |
2139 level = 254; | |
2140 block[0] = 254; | |
2141 } | |
231 | 2142 /* 0 cannot be represented also */ |
1089 | 2143 else if (level < 1) { |
231 | 2144 level = 1; |
2145 block[0] = 1; | |
2146 } | |
1090 | 2147 if (level == 128) //FIXME check rv10 |
1089 | 2148 put_bits(&s->pb, 8, 0xff); |
2149 else | |
1757
3906ddbaffec
optimization & bugfix extracted from the 4k line diff between ffmpeg 0.4.7 and http://www.alicestreet.com/ffh263.html
michael
parents:
1752
diff
changeset
|
2150 put_bits(&s->pb, 8, level); |
1089 | 2151 i = 1; |
0 | 2152 } else { |
1089 | 2153 i = 0; |
2154 if (s->h263_aic && s->mb_intra) | |
2155 rl = &rl_intra_aic; | |
2967 | 2156 |
1637 | 2157 if(s->alt_inter_vlc && !s->mb_intra){ |
2158 int aic_vlc_bits=0; | |
2159 int inter_vlc_bits=0; | |
2160 int wrong_pos=-1; | |
2161 int aic_code; | |
2967 | 2162 |
1637 | 2163 last_index = s->block_last_index[n]; |
2164 last_non_zero = i - 1; | |
2165 for (; i <= last_index; i++) { | |
2166 j = s->intra_scantable.permutated[i]; | |
2167 level = block[j]; | |
2168 if (level) { | |
2169 run = i - last_non_zero - 1; | |
2170 last = (i == last_index); | |
2967 | 2171 |
1663 | 2172 if(level<0) level= -level; |
2967 | 2173 |
1637 | 2174 code = get_rl_index(rl, last, run, level); |
2175 aic_code = get_rl_index(&rl_intra_aic, last, run, level); | |
2176 inter_vlc_bits += rl->table_vlc[code][1]+1; | |
2177 aic_vlc_bits += rl_intra_aic.table_vlc[aic_code][1]+1; | |
2178 | |
2179 if (code == rl->n) { | |
1663 | 2180 inter_vlc_bits += 1+6+8-1; |
2967 | 2181 } |
1637 | 2182 if (aic_code == rl_intra_aic.n) { |
1663 | 2183 aic_vlc_bits += 1+6+8-1; |
1637 | 2184 wrong_pos += run + 1; |
2185 }else | |
2186 wrong_pos += wrong_run[aic_code]; | |
2187 last_non_zero = i; | |
2967 | 2188 } |
1637 | 2189 } |
2190 i = 0; | |
2191 if(aic_vlc_bits < inter_vlc_bits && wrong_pos > 63) | |
2192 rl = &rl_intra_aic; | |
2193 } | |
0 | 2194 } |
2967 | 2195 |
0 | 2196 /* AC coefs */ |
2197 last_index = s->block_last_index[n]; | |
2198 last_non_zero = i - 1; | |
2199 for (; i <= last_index; i++) { | |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
702
diff
changeset
|
2200 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
|
2201 level = block[j]; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
2202 if (level) { |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
2203 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
|
2204 last = (i == last_index); |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
2205 sign = 0; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
2206 slevel = level; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
2207 if (level < 0) { |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
2208 sign = 1; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
2209 level = -level; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
2210 } |
0 | 2211 code = get_rl_index(rl, last, run, level); |
2212 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]); | |
2213 if (code == rl->n) { | |
1354 | 2214 if(s->h263_flv <= 1){ |
0 | 2215 put_bits(&s->pb, 1, last); |
2216 put_bits(&s->pb, 6, run); | |
2967 | 2217 |
1089 | 2218 assert(slevel != 0); |
2219 | |
2967 | 2220 if(level < 128) |
7260
3ec34b551aae
bitstream: move put_sbits() from flacenc.c to bitstream.h and use it
ramiro
parents:
7098
diff
changeset
|
2221 put_sbits(&s->pb, 8, slevel); |
1089 | 2222 else{ |
2223 put_bits(&s->pb, 8, 128); | |
7260
3ec34b551aae
bitstream: move put_sbits() from flacenc.c to bitstream.h and use it
ramiro
parents:
7098
diff
changeset
|
2224 put_sbits(&s->pb, 5, slevel); |
3ec34b551aae
bitstream: move put_sbits() from flacenc.c to bitstream.h and use it
ramiro
parents:
7098
diff
changeset
|
2225 put_sbits(&s->pb, 6, slevel>>5); |
1089 | 2226 } |
1354 | 2227 }else{ |
1757
3906ddbaffec
optimization & bugfix extracted from the 4k line diff between ffmpeg 0.4.7 and http://www.alicestreet.com/ffh263.html
michael
parents:
1752
diff
changeset
|
2228 if(level < 64) { // 7-bit level |
1354 | 2229 put_bits(&s->pb, 1, 0); |
2230 put_bits(&s->pb, 1, last); | |
2231 put_bits(&s->pb, 6, run); | |
2232 | |
7260
3ec34b551aae
bitstream: move put_sbits() from flacenc.c to bitstream.h and use it
ramiro
parents:
7098
diff
changeset
|
2233 put_sbits(&s->pb, 7, slevel); |
1354 | 2234 } else { |
2235 /* 11-bit level */ | |
2236 put_bits(&s->pb, 1, 1); | |
2237 put_bits(&s->pb, 1, last); | |
2238 put_bits(&s->pb, 6, run); | |
2239 | |
7260
3ec34b551aae
bitstream: move put_sbits() from flacenc.c to bitstream.h and use it
ramiro
parents:
7098
diff
changeset
|
2240 put_sbits(&s->pb, 11, slevel); |
1354 | 2241 } |
2242 } | |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
2243 } else { |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
2244 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
|
2245 } |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
2246 last_non_zero = i; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
2247 } |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
2248 } |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
2249 } |
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
|
2250 |
0 | 2251 /***************************************************/ |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2252 /** |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2253 * add mpeg4 stuffing bits (01...1) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2254 */ |
453 | 2255 void ff_mpeg4_stuffing(PutBitContext * pbc) |
262 | 2256 { |
2257 int length; | |
2258 put_bits(pbc, 1, 0); | |
1786 | 2259 length= (-put_bits_count(pbc))&7; |
453 | 2260 if(length) put_bits(pbc, length, (1<<length)-1); |
262 | 2261 } |
2262 | |
327 | 2263 /* must be called before writing the header */ |
5273
101f20612a94
Split ff_set_mpeg4_time() and move the non mpeg4 specific part
aurel
parents:
5268
diff
changeset
|
2264 void ff_set_mpeg4_time(MpegEncContext * s){ |
6481 | 2265 if(s->pict_type==FF_B_TYPE){ |
3247 | 2266 ff_mpeg4_init_direct_mv(s); |
327 | 2267 }else{ |
2268 s->last_time_base= s->time_base; | |
5273
101f20612a94
Split ff_set_mpeg4_time() and move the non mpeg4 specific part
aurel
parents:
5268
diff
changeset
|
2269 s->time_base= s->time/s->avctx->time_base.den; |
327 | 2270 } |
2271 } | |
2272 | |
942 | 2273 static void mpeg4_encode_gop_header(MpegEncContext * s){ |
2274 int hours, minutes, seconds; | |
1763
951403db901f
first coded vs. first displayed pts (segfault & pts fix if b frames are used)
michael
parents:
1760
diff
changeset
|
2275 int64_t time; |
2967 | 2276 |
942 | 2277 put_bits(&s->pb, 16, 0); |
2278 put_bits(&s->pb, 16, GOP_STARTCODE); | |
2967 | 2279 |
1831
cd2d7fcfab7a
use AVFrame.pts=AV_NOPTS_VALUE instead of AVFrame.pts=0
michael
parents:
1829
diff
changeset
|
2280 time= s->current_picture_ptr->pts; |
cd2d7fcfab7a
use AVFrame.pts=AV_NOPTS_VALUE instead of AVFrame.pts=0
michael
parents:
1829
diff
changeset
|
2281 if(s->reordered_input_picture[1]) |
cd2d7fcfab7a
use AVFrame.pts=AV_NOPTS_VALUE instead of AVFrame.pts=0
michael
parents:
1829
diff
changeset
|
2282 time= FFMIN(time, s->reordered_input_picture[1]->pts); |
2637 | 2283 time= time*s->avctx->time_base.num; |
2284 | |
2285 seconds= time/s->avctx->time_base.den; | |
942 | 2286 minutes= seconds/60; seconds %= 60; |
2287 hours= minutes/60; minutes %= 60; | |
2288 hours%=24; | |
2289 | |
2290 put_bits(&s->pb, 5, hours); | |
2291 put_bits(&s->pb, 6, minutes); | |
2292 put_bits(&s->pb, 1, 1); | |
2293 put_bits(&s->pb, 6, seconds); | |
2967 | 2294 |
2295 put_bits(&s->pb, 1, !!(s->flags&CODEC_FLAG_CLOSED_GOP)); | |
942 | 2296 put_bits(&s->pb, 1, 0); //broken link == NO |
2967 | 2297 |
2298 s->last_time_base= time / s->avctx->time_base.den; | |
942 | 2299 |
2300 ff_mpeg4_stuffing(&s->pb); | |
2301 } | |
2302 | |
2303 static void mpeg4_encode_visual_object_header(MpegEncContext * s){ | |
2304 int profile_and_level_indication; | |
2305 int vo_ver_id; | |
2967 | 2306 |
2167 | 2307 if(s->avctx->profile != FF_PROFILE_UNKNOWN){ |
2308 profile_and_level_indication = s->avctx->profile << 4; | |
2309 }else if(s->max_b_frames || s->quarter_sample){ | |
2310 profile_and_level_indication= 0xF0; // adv simple | |
2311 }else{ | |
2312 profile_and_level_indication= 0x00; // simple | |
2313 } | |
2314 | |
2315 if(s->avctx->level != FF_LEVEL_UNKNOWN){ | |
2316 profile_and_level_indication |= s->avctx->level; | |
2317 }else{ | |
2318 profile_and_level_indication |= 1; //level 1 | |
2319 } | |
2320 | |
2321 if(profile_and_level_indication>>4 == 0xF){ | |
942 | 2322 vo_ver_id= 5; |
2323 }else{ | |
2324 vo_ver_id= 1; | |
2325 } | |
2167 | 2326 |
942 | 2327 //FIXME levels |
2328 | |
2329 put_bits(&s->pb, 16, 0); | |
2330 put_bits(&s->pb, 16, VOS_STARTCODE); | |
1350
e7c8051e1849
the reference sw doesnt like some legal headers ...
michaelni
parents:
1346
diff
changeset
|
2331 |
942 | 2332 put_bits(&s->pb, 8, profile_and_level_indication); |
1350
e7c8051e1849
the reference sw doesnt like some legal headers ...
michaelni
parents:
1346
diff
changeset
|
2333 |
942 | 2334 put_bits(&s->pb, 16, 0); |
2335 put_bits(&s->pb, 16, VISUAL_OBJ_STARTCODE); | |
2967 | 2336 |
942 | 2337 put_bits(&s->pb, 1, 1); |
2338 put_bits(&s->pb, 4, vo_ver_id); | |
2339 put_bits(&s->pb, 3, 1); //priority | |
2967 | 2340 |
942 | 2341 put_bits(&s->pb, 4, 1); //visual obj type== video obj |
2967 | 2342 |
942 | 2343 put_bits(&s->pb, 1, 0); //video signal type == no clue //FIXME |
2344 | |
2345 ff_mpeg4_stuffing(&s->pb); | |
2346 } | |
2347 | |
2348 static void mpeg4_encode_vol_header(MpegEncContext * s, int vo_number, int vol_number) | |
0 | 2349 { |
942 | 2350 int vo_ver_id; |
336 | 2351 |
8596
68e959302527
replace all occurrence of ENABLE_ by the corresponding CONFIG_, HAVE_ or ARCH_
aurel
parents:
8590
diff
changeset
|
2352 if (!CONFIG_MPEG4_ENCODER) return; |
5275
91416b4f1929
Better place to disable some mpeg4 code and ensure that
aurel
parents:
5274
diff
changeset
|
2353 |
942 | 2354 if(s->max_b_frames || s->quarter_sample){ |
2355 vo_ver_id= 5; | |
923 | 2356 s->vo_type= ADV_SIMPLE_VO_TYPE; |
2357 }else{ | |
942 | 2358 vo_ver_id= 1; |
923 | 2359 s->vo_type= SIMPLE_VO_TYPE; |
2360 } | |
336 | 2361 |
263 | 2362 put_bits(&s->pb, 16, 0); |
942 | 2363 put_bits(&s->pb, 16, 0x100 + vo_number); /* video obj */ |
263 | 2364 put_bits(&s->pb, 16, 0); |
942 | 2365 put_bits(&s->pb, 16, 0x120 + vol_number); /* video obj layer */ |
263 | 2366 |
2979 | 2367 put_bits(&s->pb, 1, 0); /* random access vol */ |
2368 put_bits(&s->pb, 8, s->vo_type); /* video obj type indication */ | |
2572
c22ad129a91b
support omiting various headers in mpeg4 as WMP seems to have difficulty with them
michael
parents:
2554
diff
changeset
|
2369 if(s->workaround_bugs & FF_BUG_MS) { |
2979 | 2370 put_bits(&s->pb, 1, 0); /* is obj layer id= no */ |
2572
c22ad129a91b
support omiting various headers in mpeg4 as WMP seems to have difficulty with them
michael
parents:
2554
diff
changeset
|
2371 } else { |
2979 | 2372 put_bits(&s->pb, 1, 1); /* is obj layer id= yes */ |
2373 put_bits(&s->pb, 4, vo_ver_id); /* is obj layer ver id */ | |
2374 put_bits(&s->pb, 3, 1); /* is obj layer priority */ | |
2572
c22ad129a91b
support omiting various headers in mpeg4 as WMP seems to have difficulty with them
michael
parents:
2554
diff
changeset
|
2375 } |
2967 | 2376 |
1548 | 2377 aspect_to_info(s, s->avctx->sample_aspect_ratio); |
880 | 2378 |
2379 put_bits(&s->pb, 4, s->aspect_ratio_info);/* aspect ratio info */ | |
1548 | 2380 if (s->aspect_ratio_info == FF_ASPECT_EXTENDED){ |
2381 put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.num); | |
2382 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
|
2383 } |
336 | 2384 |
2572
c22ad129a91b
support omiting various headers in mpeg4 as WMP seems to have difficulty with them
michael
parents:
2554
diff
changeset
|
2385 if(s->workaround_bugs & FF_BUG_MS) { // |
2979 | 2386 put_bits(&s->pb, 1, 0); /* vol control parameters= no @@@ */ |
2572
c22ad129a91b
support omiting various headers in mpeg4 as WMP seems to have difficulty with them
michael
parents:
2554
diff
changeset
|
2387 } else { |
2979 | 2388 put_bits(&s->pb, 1, 1); /* vol control parameters= yes */ |
2389 put_bits(&s->pb, 2, 1); /* chroma format YUV 420/YV12 */ | |
2572
c22ad129a91b
support omiting various headers in mpeg4 as WMP seems to have difficulty with them
michael
parents:
2554
diff
changeset
|
2390 put_bits(&s->pb, 1, s->low_delay); |
2979 | 2391 put_bits(&s->pb, 1, 0); /* vbv parameters= no */ |
2392 } | |
2393 | |
2394 put_bits(&s->pb, 2, RECT_SHAPE); /* vol shape= rectangle */ | |
2395 put_bits(&s->pb, 1, 1); /* marker bit */ | |
2967 | 2396 |
2637 | 2397 put_bits(&s->pb, 16, s->avctx->time_base.den); |
263 | 2398 if (s->time_increment_bits < 1) |
2399 s->time_increment_bits = 1; | |
2979 | 2400 put_bits(&s->pb, 1, 1); /* marker bit */ |
2401 put_bits(&s->pb, 1, 0); /* fixed vop rate=no */ | |
2402 put_bits(&s->pb, 1, 1); /* marker bit */ | |
2403 put_bits(&s->pb, 13, s->width); /* vol width */ | |
2404 put_bits(&s->pb, 1, 1); /* marker bit */ | |
2405 put_bits(&s->pb, 13, s->height); /* vol height */ | |
2406 put_bits(&s->pb, 1, 1); /* marker bit */ | |
697 | 2407 put_bits(&s->pb, 1, s->progressive_sequence ? 0 : 1); |
2979 | 2408 put_bits(&s->pb, 1, 1); /* obmc disable */ |
263 | 2409 if (vo_ver_id == 1) { |
2979 | 2410 put_bits(&s->pb, 1, s->vol_sprite_usage); /* sprite enable */ |
942 | 2411 }else{ |
2979 | 2412 put_bits(&s->pb, 2, s->vol_sprite_usage); /* sprite enable */ |
2413 } | |
2414 | |
2415 put_bits(&s->pb, 1, 0); /* not 8 bit == false */ | |
2416 put_bits(&s->pb, 1, s->mpeg_quant); /* quant type= (0=h263 style)*/ | |
1411 | 2417 |
2418 if(s->mpeg_quant){ | |
2419 ff_write_quant_matrix(&s->pb, s->avctx->intra_matrix); | |
2420 ff_write_quant_matrix(&s->pb, s->avctx->inter_matrix); | |
2421 } | |
599 | 2422 |
263 | 2423 if (vo_ver_id != 1) |
936 | 2424 put_bits(&s->pb, 1, s->quarter_sample); |
2979 | 2425 put_bits(&s->pb, 1, 1); /* complexity estimation disable */ |
453 | 2426 s->resync_marker= s->rtp_mode; |
2427 put_bits(&s->pb, 1, s->resync_marker ? 0 : 1);/* resync marker disable */ | |
2428 put_bits(&s->pb, 1, s->data_partitioning ? 1 : 0); | |
2429 if(s->data_partitioning){ | |
2979 | 2430 put_bits(&s->pb, 1, 0); /* no rvlc */ |
453 | 2431 } |
2432 | |
263 | 2433 if (vo_ver_id != 1){ |
2979 | 2434 put_bits(&s->pb, 1, 0); /* newpred */ |
2435 put_bits(&s->pb, 1, 0); /* reduced res vop */ | |
2436 } | |
2437 put_bits(&s->pb, 1, 0); /* scalability */ | |
2967 | 2438 |
453 | 2439 ff_mpeg4_stuffing(&s->pb); |
676 | 2440 |
2441 /* user data */ | |
1092 | 2442 if(!(s->flags & CODEC_FLAG_BITEXACT)){ |
676 | 2443 put_bits(&s->pb, 16, 0); |
2979 | 2444 put_bits(&s->pb, 16, 0x1B2); /* user_data */ |
2445 ff_put_string(&s->pb, LIBAVCODEC_IDENT, 0); | |
676 | 2446 } |
263 | 2447 } |
2448 | |
2449 /* write mpeg4 VOP header */ | |
2450 void mpeg4_encode_picture_header(MpegEncContext * s, int picture_number) | |
2451 { | |
324 | 2452 int time_incr; |
2453 int time_div, time_mod; | |
2967 | 2454 |
6481 | 2455 if(s->pict_type==FF_I_TYPE){ |
953 | 2456 if(!(s->flags&CODEC_FLAG_GLOBAL_HEADER)){ |
2658
d1609cfeb1d0
#defines for strict_std_compliance and split between inofficial extensions and non standarized things
michael
parents:
2646
diff
changeset
|
2457 if(s->strict_std_compliance < FF_COMPLIANCE_VERY_STRICT) //HACK, the reference sw is buggy |
1350
e7c8051e1849
the reference sw doesnt like some legal headers ...
michaelni
parents:
1346
diff
changeset
|
2458 mpeg4_encode_visual_object_header(s); |
2658
d1609cfeb1d0
#defines for strict_std_compliance and split between inofficial extensions and non standarized things
michael
parents:
2646
diff
changeset
|
2459 if(s->strict_std_compliance < FF_COMPLIANCE_VERY_STRICT || picture_number==0) //HACK, the reference sw is buggy |
1350
e7c8051e1849
the reference sw doesnt like some legal headers ...
michaelni
parents:
1346
diff
changeset
|
2460 mpeg4_encode_vol_header(s, 0, 0); |
942 | 2461 } |
2572
c22ad129a91b
support omiting various headers in mpeg4 as WMP seems to have difficulty with them
michael
parents:
2554
diff
changeset
|
2462 if(!(s->workaround_bugs & FF_BUG_MS)) |
c22ad129a91b
support omiting various headers in mpeg4 as WMP seems to have difficulty with them
michael
parents:
2554
diff
changeset
|
2463 mpeg4_encode_gop_header(s); |
453 | 2464 } |
2967 | 2465 |
6481 | 2466 s->partitioned_frame= s->data_partitioning && s->pict_type!=FF_B_TYPE; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2467 |
2637 | 2468 //printf("num:%d rate:%d base:%d\n", s->picture_number, s->time_base.den, FRAME_RATE_BASE); |
2967 | 2469 |
2979 | 2470 put_bits(&s->pb, 16, 0); /* vop header */ |
2471 put_bits(&s->pb, 16, VOP_STARTCODE); /* vop header */ | |
2472 put_bits(&s->pb, 2, s->pict_type - 1); /* pict type: I = 0 , P = 1 */ | |
324 | 2473 |
2679 | 2474 assert(s->time>=0); |
2637 | 2475 time_div= s->time/s->avctx->time_base.den; |
2476 time_mod= s->time%s->avctx->time_base.den; | |
324 | 2477 time_incr= time_div - s->last_time_base; |
1936
e5b0b33cf8aa
assert(time_incr >= 0) so its clear that this MUST be the case
michael
parents:
1914
diff
changeset
|
2478 assert(time_incr >= 0); |
324 | 2479 while(time_incr--) |
2480 put_bits(&s->pb, 1, 1); | |
2967 | 2481 |
0 | 2482 put_bits(&s->pb, 1, 0); |
2483 | |
2979 | 2484 put_bits(&s->pb, 1, 1); /* marker */ |
2485 put_bits(&s->pb, s->time_increment_bits, time_mod); /* time increment */ | |
2486 put_bits(&s->pb, 1, 1); /* marker */ | |
2487 put_bits(&s->pb, 1, 1); /* vop coded */ | |
6481 | 2488 if ( s->pict_type == FF_P_TYPE |
2489 || (s->pict_type == FF_S_TYPE && s->vol_sprite_usage==GMC_SPRITE)) { | |
2979 | 2490 put_bits(&s->pb, 1, s->no_rounding); /* rounding type */ |
2491 } | |
2492 put_bits(&s->pb, 3, 0); /* intra dc VLC threshold */ | |
697 | 2493 if(!s->progressive_sequence){ |
1659 | 2494 put_bits(&s->pb, 1, s->current_picture_ptr->top_field_first); |
697 | 2495 put_bits(&s->pb, 1, s->alternate_scan); |
2496 } | |
263 | 2497 //FIXME sprite stuff |
0 | 2498 |
2499 put_bits(&s->pb, 5, s->qscale); | |
2500 | |
6481 | 2501 if (s->pict_type != FF_I_TYPE) |
2979 | 2502 put_bits(&s->pb, 3, s->f_code); /* fcode_for */ |
6481 | 2503 if (s->pict_type == FF_B_TYPE) |
2979 | 2504 put_bits(&s->pb, 3, s->b_code); /* fcode_back */ |
0 | 2505 // printf("****frame %d\n", picture_number); |
2506 } | |
2507 | |
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
|
2508 #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
|
2509 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2510 /** |
1034 | 2511 * predicts the dc. |
2003 | 2512 * encoding quantized level -> quantized diff |
2967 | 2513 * decoding quantized diff -> quantized level |
1034 | 2514 * @param n block index (0-3 are luma, 4-5 are chroma) |
2515 * @param dir_ptr pointer to an integer where the prediction direction will be stored | |
2516 */ | |
2003 | 2517 static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, int level, int *dir_ptr, int encoding) |
0 | 2518 { |
2003 | 2519 int a, b, c, wrap, pred, scale, ret; |
3781 | 2520 int16_t *dc_val; |
0 | 2521 |
2522 /* find prediction */ | |
2523 if (n < 4) { | |
2979 | 2524 scale = s->y_dc_scale; |
0 | 2525 } else { |
2979 | 2526 scale = s->c_dc_scale; |
0 | 2527 } |
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
|
2528 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
|
2529 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
|
2530 |
266 | 2531 wrap= s->block_wrap[n]; |
2532 dc_val = s->dc_val[0] + s->block_index[n]; | |
0 | 2533 |
2534 /* B C | |
2967 | 2535 * A X |
0 | 2536 */ |
266 | 2537 a = dc_val[ - 1]; |
2538 b = dc_val[ - 1 - wrap]; | |
2539 c = dc_val[ - wrap]; | |
0 | 2540 |
2646
c735e3e60ca7
Even More spelling errors. patch by (Kevin Baragona <kevinmb500 gawab com)
michael
parents:
2639
diff
changeset
|
2541 /* outside slice handling (we can't do that by memset as we need the dc for error resilience) */ |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2542 if(s->first_slice_line && n!=3){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2543 if(n!=2) b=c= 1024; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2544 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
|
2545 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2546 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
|
2547 if(n==0 || n==4 || n==5) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2548 b=1024; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2549 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2550 |
0 | 2551 if (abs(a - b) < abs(b - c)) { |
2979 | 2552 pred = c; |
0 | 2553 *dir_ptr = 1; /* top */ |
2554 } else { | |
2979 | 2555 pred = a; |
0 | 2556 *dir_ptr = 0; /* left */ |
2557 } | |
2558 /* 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
|
2559 pred = FASTDIV((pred + (scale >> 1)), scale); |
0 | 2560 |
2003 | 2561 if(encoding){ |
2562 ret = level - pred; | |
2563 }else{ | |
2564 level += pred; | |
2565 ret= level; | |
7831 | 2566 if(s->error_recognition>=3){ |
2003 | 2567 if(level<0){ |
2568 av_log(s->avctx, AV_LOG_ERROR, "dc<0 at %dx%d\n", s->mb_x, s->mb_y); | |
2569 return -1; | |
2570 } | |
2571 if(level*scale > 2048 + scale){ | |
2572 av_log(s->avctx, AV_LOG_ERROR, "dc overflow at %dx%d\n", s->mb_x, s->mb_y); | |
2573 return -1; | |
2574 } | |
2575 } | |
2576 } | |
2577 level *=scale; | |
2004 | 2578 if(level&(~2047)){ |
2967 | 2579 if(level<0) |
2004 | 2580 level=0; |
2581 else if(!(s->workaround_bugs&FF_BUG_DC_CLIP)) | |
2582 level=2047; | |
2583 } | |
2003 | 2584 dc_val[0]= level; |
2585 | |
2586 return ret; | |
0 | 2587 } |
2588 | |
1034 | 2589 /** |
2590 * predicts the ac. | |
2591 * @param n block index (0-3 are luma, 4-5 are chroma) | |
2592 * @param dir the ac prediction direction | |
2593 */ | |
1008 | 2594 void mpeg4_pred_ac(MpegEncContext * s, DCTELEM *block, int n, |
0 | 2595 int dir) |
2596 { | |
266 | 2597 int i; |
1064 | 2598 int16_t *ac_val, *ac_val1; |
903 | 2599 int8_t * const qscale_table= s->current_picture.qscale_table; |
0 | 2600 |
2601 /* find prediction */ | |
266 | 2602 ac_val = s->ac_val[0][0] + s->block_index[n] * 16; |
0 | 2603 ac_val1 = ac_val; |
2604 if (s->ac_pred) { | |
2605 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
|
2606 const int xy= s->mb_x-1 + s->mb_y*s->mb_stride; |
0 | 2607 /* left prediction */ |
2608 ac_val -= 16; | |
2967 | 2609 |
903 | 2610 if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){ |
575 | 2611 /* same qscale */ |
2612 for(i=1;i<8;i++) { | |
1092 | 2613 block[s->dsp.idct_permutation[i<<3]] += ac_val[i]; |
575 | 2614 } |
2615 }else{ | |
2616 /* different qscale, we must rescale */ | |
2617 for(i=1;i<8;i++) { | |
1092 | 2618 block[s->dsp.idct_permutation[i<<3]] += ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale); |
575 | 2619 } |
0 | 2620 } |
2621 } 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
|
2622 const int xy= s->mb_x + s->mb_y*s->mb_stride - s->mb_stride; |
0 | 2623 /* top prediction */ |
266 | 2624 ac_val -= 16 * s->block_wrap[n]; |
575 | 2625 |
903 | 2626 if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){ |
575 | 2627 /* same qscale */ |
2628 for(i=1;i<8;i++) { | |
1092 | 2629 block[s->dsp.idct_permutation[i]] += ac_val[i + 8]; |
575 | 2630 } |
2631 }else{ | |
2632 /* different qscale, we must rescale */ | |
2633 for(i=1;i<8;i++) { | |
1092 | 2634 block[s->dsp.idct_permutation[i]] += ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale); |
575 | 2635 } |
0 | 2636 } |
2637 } | |
2638 } | |
2639 /* left copy */ | |
2640 for(i=1;i<8;i++) | |
1092 | 2641 ac_val1[i ] = block[s->dsp.idct_permutation[i<<3]]; |
591 | 2642 |
0 | 2643 /* top copy */ |
2644 for(i=1;i<8;i++) | |
1092 | 2645 ac_val1[8 + i] = block[s->dsp.idct_permutation[i ]]; |
591 | 2646 |
0 | 2647 } |
2648 | |
8590 | 2649 #if CONFIG_ENCODERS |
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
|
2650 |
1034 | 2651 /** |
2652 * encodes the dc value. | |
2653 * @param n block index (0-3 are luma, 4-5 are chroma) | |
2654 */ | |
453 | 2655 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
|
2656 { |
293 | 2657 #if 1 |
453 | 2658 // if(level<-255 || level>255) printf("dc overflow\n"); |
293 | 2659 level+=256; |
2660 if (n < 4) { | |
2979 | 2661 /* luminance */ |
2662 put_bits(s, uni_DCtab_lum_len[level], uni_DCtab_lum_bits[level]); | |
293 | 2663 } else { |
2979 | 2664 /* chrominance */ |
2665 put_bits(s, uni_DCtab_chrom_len[level], uni_DCtab_chrom_bits[level]); | |
293 | 2666 } |
2667 #else | |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
2668 int size, v; |
0 | 2669 /* find number of bits */ |
2670 size = 0; | |
2671 v = abs(level); | |
2672 while (v) { | |
2979 | 2673 v >>= 1; |
2674 size++; | |
0 | 2675 } |
2676 | |
2677 if (n < 4) { | |
2979 | 2678 /* luminance */ |
2679 put_bits(&s->pb, DCtab_lum[size][1], DCtab_lum[size][0]); | |
0 | 2680 } else { |
2979 | 2681 /* chrominance */ |
2682 put_bits(&s->pb, DCtab_chrom[size][1], DCtab_chrom[size][0]); | |
0 | 2683 } |
2684 | |
2685 /* encode remaining bits */ | |
2686 if (size > 0) { | |
2979 | 2687 if (level < 0) |
2688 level = (-level) ^ ((1 << size) - 1); | |
2689 put_bits(&s->pb, size, level); | |
2690 if (size > 8) | |
2691 put_bits(&s->pb, 1, 1); | |
0 | 2692 } |
293 | 2693 #endif |
0 | 2694 } |
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
|
2695 |
2502 | 2696 static inline int mpeg4_get_dc_length(int level, int n){ |
2697 if (n < 4) { | |
2698 return uni_DCtab_lum_len[level + 256]; | |
2699 } else { | |
2700 return uni_DCtab_chrom_len[level + 256]; | |
2701 } | |
2702 } | |
2703 | |
1034 | 2704 /** |
2705 * encodes a 8x8 block | |
2706 * @param n block index (0-3 are luma, 4-5 are chroma) | |
2707 */ | |
2967 | 2708 static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n, int intra_dc, |
1064 | 2709 uint8_t *scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb) |
0 | 2710 { |
751 | 2711 int i, last_non_zero; |
2712 #if 0 //variables for the outcommented version | |
2713 int code, sign, last; | |
2714 #endif | |
0 | 2715 const RLTable *rl; |
1064 | 2716 uint32_t *bits_tab; |
2717 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
|
2718 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
|
2719 |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
2720 if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away |
2979 | 2721 /* mpeg4 based DC predictor */ |
2722 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
|
2723 if(last_index<1) return; |
2979 | 2724 i = 1; |
0 | 2725 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
|
2726 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
|
2727 len_tab = uni_mpeg4_intra_rl_len; |
0 | 2728 } 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
|
2729 if(last_index<0) return; |
2979 | 2730 i = 0; |
0 | 2731 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
|
2732 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
|
2733 len_tab = uni_mpeg4_inter_rl_len; |
0 | 2734 } |
2735 | |
2736 /* AC coefs */ | |
2737 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
|
2738 #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
|
2739 for (; i < last_index; i++) { |
2979 | 2740 int level = block[ scan_table[i] ]; |
2741 if (level) { | |
2742 int run = i - last_non_zero - 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
|
2743 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
|
2744 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
|
2745 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
|
2746 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
|
2747 }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
|
2748 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
|
2749 } |
2979 | 2750 last_non_zero = i; |
2751 } | |
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
|
2752 } |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
2753 /*if(i<=last_index)*/{ |
2979 | 2754 int level = block[ scan_table[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
|
2755 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
|
2756 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
|
2757 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
|
2758 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
|
2759 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
|
2760 }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
|
2761 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
|
2762 } |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
2763 } |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
2764 #else |
0 | 2765 for (; i <= last_index; i++) { |
2979 | 2766 const int slevel = block[ scan_table[i] ]; |
2767 if (slevel) { | |
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
|
2768 int level; |
2979 | 2769 int run = i - last_non_zero - 1; |
2770 last = (i == last_index); | |
2771 sign = 0; | |
2772 level = slevel; | |
2773 if (level < 0) { | |
2774 sign = 1; | |
2775 level = -level; | |
2776 } | |
0 | 2777 code = get_rl_index(rl, last, run, level); |
453 | 2778 put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]); |
0 | 2779 if (code == rl->n) { |
2780 int level1, run1; | |
2781 level1 = level - rl->max_level[last][run]; | |
2967 | 2782 if (level1 < 1) |
0 | 2783 goto esc2; |
2784 code = get_rl_index(rl, last, run, level1); | |
2785 if (code == rl->n) { | |
2786 esc2: | |
453 | 2787 put_bits(ac_pb, 1, 1); |
0 | 2788 if (level > MAX_LEVEL) |
2789 goto esc3; | |
2790 run1 = run - rl->max_run[last][level] - 1; | |
2791 if (run1 < 0) | |
2792 goto esc3; | |
2793 code = get_rl_index(rl, last, run1, level); | |
2794 if (code == rl->n) { | |
2795 esc3: | |
2796 /* third escape */ | |
453 | 2797 put_bits(ac_pb, 1, 1); |
2798 put_bits(ac_pb, 1, last); | |
2799 put_bits(ac_pb, 6, run); | |
2800 put_bits(ac_pb, 1, 1); | |
7260
3ec34b551aae
bitstream: move put_sbits() from flacenc.c to bitstream.h and use it
ramiro
parents:
7098
diff
changeset
|
2801 put_sbits(ac_pb, 12, slevel); |
453 | 2802 put_bits(ac_pb, 1, 1); |
0 | 2803 } else { |
2804 /* second escape */ | |
453 | 2805 put_bits(ac_pb, 1, 0); |
2806 put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]); | |
2807 put_bits(ac_pb, 1, sign); | |
0 | 2808 } |
2809 } else { | |
2810 /* first escape */ | |
453 | 2811 put_bits(ac_pb, 1, 0); |
2812 put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]); | |
2813 put_bits(ac_pb, 1, sign); | |
0 | 2814 } |
2815 } else { | |
453 | 2816 put_bits(ac_pb, 1, sign); |
0 | 2817 } |
2979 | 2818 last_non_zero = i; |
2819 } | |
0 | 2820 } |
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
|
2821 #endif |
0 | 2822 } |
936 | 2823 |
2967 | 2824 static int mpeg4_get_block_length(MpegEncContext * s, DCTELEM * block, int n, int intra_dc, |
1064 | 2825 uint8_t *scan_table) |
936 | 2826 { |
2827 int i, last_non_zero; | |
1064 | 2828 uint8_t *len_tab; |
936 | 2829 const int last_index = s->block_last_index[n]; |
2830 int len=0; | |
2831 | |
2832 if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away | |
2979 | 2833 /* mpeg4 based DC predictor */ |
2834 len += mpeg4_get_dc_length(intra_dc, n); | |
936 | 2835 if(last_index<1) return len; |
2979 | 2836 i = 1; |
936 | 2837 len_tab = uni_mpeg4_intra_rl_len; |
2838 } else { | |
2839 if(last_index<0) return 0; | |
2979 | 2840 i = 0; |
936 | 2841 len_tab = uni_mpeg4_inter_rl_len; |
2842 } | |
2843 | |
2844 /* AC coefs */ | |
2845 last_non_zero = i - 1; | |
2846 for (; i < last_index; i++) { | |
2979 | 2847 int level = block[ scan_table[i] ]; |
2848 if (level) { | |
2849 int run = i - last_non_zero - 1; | |
936 | 2850 level+=64; |
2851 if((level&(~127)) == 0){ | |
2852 const int index= UNI_MPEG4_ENC_INDEX(0, run, level); | |
2853 len += len_tab[index]; | |
2854 }else{ //ESC3 | |
2855 len += 7+2+1+6+1+12+1; | |
2856 } | |
2979 | 2857 last_non_zero = i; |
2858 } | |
936 | 2859 } |
2860 /*if(i<=last_index)*/{ | |
2979 | 2861 int level = block[ scan_table[i] ]; |
936 | 2862 int run = i - last_non_zero - 1; |
2863 level+=64; | |
2864 if((level&(~127)) == 0){ | |
2865 const int index= UNI_MPEG4_ENC_INDEX(1, run, level); | |
2866 len += len_tab[index]; | |
2867 }else{ //ESC3 | |
2868 len += 7+2+1+6+1+12+1; | |
2869 } | |
2870 } | |
2967 | 2871 |
936 | 2872 return len; |
2873 } | |
2874 | |
815
78accc54493b
put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents:
770
diff
changeset
|
2875 #endif |
0 | 2876 |
2877 | |
2878 /***********************************************/ | |
2879 /* decoding */ | |
2880 | |
2881 static VLC intra_MCBPC_vlc; | |
2882 static VLC inter_MCBPC_vlc; | |
2883 static VLC cbpy_vlc; | |
2884 static VLC mv_vlc; | |
2885 static VLC dc_lum, dc_chrom; | |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
2886 static VLC sprite_trajectory; |
262 | 2887 static VLC mb_type_b_vlc; |
1655 | 2888 static VLC h263_mbtype_b_vlc; |
2889 static VLC cbpc_b_vlc; | |
0 | 2890 |
2891 /* init vlcs */ | |
2892 | |
2893 /* XXX: find a better solution to handle static init */ | |
2894 void h263_decode_init_vlc(MpegEncContext *s) | |
2895 { | |
2896 static int done = 0; | |
2897 | |
2898 if (!done) { | |
2899 done = 1; | |
2900 | |
7098 | 2901 INIT_VLC_STATIC(&intra_MCBPC_vlc, INTRA_MCBPC_VLC_BITS, 9, |
0 | 2902 intra_MCBPC_bits, 1, 1, |
7098 | 2903 intra_MCBPC_code, 1, 1, 72); |
2904 INIT_VLC_STATIC(&inter_MCBPC_vlc, INTER_MCBPC_VLC_BITS, 28, | |
0 | 2905 inter_MCBPC_bits, 1, 1, |
7098 | 2906 inter_MCBPC_code, 1, 1, 198); |
2907 INIT_VLC_STATIC(&cbpy_vlc, CBPY_VLC_BITS, 16, | |
0 | 2908 &cbpy_tab[0][1], 2, 1, |
7098 | 2909 &cbpy_tab[0][0], 2, 1, 64); |
2910 INIT_VLC_STATIC(&mv_vlc, MV_VLC_BITS, 33, | |
0 | 2911 &mvtab[0][1], 2, 1, |
7098 | 2912 &mvtab[0][0], 2, 1, 538); |
4668 | 2913 init_rl(&rl_inter, static_rl_table_store[0]); |
2914 init_rl(&rl_intra, static_rl_table_store[1]); | |
2915 init_rl(&rvlc_rl_inter, static_rl_table_store[3]); | |
2916 init_rl(&rvlc_rl_intra, static_rl_table_store[4]); | |
2917 init_rl(&rl_intra_aic, static_rl_table_store[2]); | |
6940
778ecab25dd8
Change init_vlc_rl() so it does not use *alloc_static() anymore.
michael
parents:
6918
diff
changeset
|
2918 INIT_VLC_RL(rl_inter, 554); |
778ecab25dd8
Change init_vlc_rl() so it does not use *alloc_static() anymore.
michael
parents:
6918
diff
changeset
|
2919 INIT_VLC_RL(rl_intra, 554); |
778ecab25dd8
Change init_vlc_rl() so it does not use *alloc_static() anymore.
michael
parents:
6918
diff
changeset
|
2920 INIT_VLC_RL(rvlc_rl_inter, 1072); |
778ecab25dd8
Change init_vlc_rl() so it does not use *alloc_static() anymore.
michael
parents:
6918
diff
changeset
|
2921 INIT_VLC_RL(rvlc_rl_intra, 1072); |
778ecab25dd8
Change init_vlc_rl() so it does not use *alloc_static() anymore.
michael
parents:
6918
diff
changeset
|
2922 INIT_VLC_RL(rl_intra_aic, 554); |
7098 | 2923 INIT_VLC_STATIC(&dc_lum, DC_VLC_BITS, 10 /* 13 */, |
0 | 2924 &DCtab_lum[0][1], 2, 1, |
7098 | 2925 &DCtab_lum[0][0], 2, 1, 512); |
2926 INIT_VLC_STATIC(&dc_chrom, DC_VLC_BITS, 10 /* 13 */, | |
0 | 2927 &DCtab_chrom[0][1], 2, 1, |
7098 | 2928 &DCtab_chrom[0][0], 2, 1, 512); |
2929 INIT_VLC_STATIC(&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
|
2930 &sprite_trajectory_tab[0][1], 4, 2, |
7098 | 2931 &sprite_trajectory_tab[0][0], 4, 2, 128); |
2932 INIT_VLC_STATIC(&mb_type_b_vlc, MB_TYPE_B_VLC_BITS, 4, | |
262 | 2933 &mb_type_b_tab[0][1], 2, 1, |
7098 | 2934 &mb_type_b_tab[0][0], 2, 1, 16); |
2935 INIT_VLC_STATIC(&h263_mbtype_b_vlc, H263_MBTYPE_B_VLC_BITS, 15, | |
1655 | 2936 &h263_mbtype_b_tab[0][1], 2, 1, |
7098 | 2937 &h263_mbtype_b_tab[0][0], 2, 1, 80); |
2938 INIT_VLC_STATIC(&cbpc_b_vlc, CBPC_B_VLC_BITS, 4, | |
1655 | 2939 &cbpc_b_tab[0][1], 2, 1, |
7098 | 2940 &cbpc_b_tab[0][0], 2, 1, 8); |
0 | 2941 } |
2942 } | |
2943 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2944 /** |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2945 * 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
|
2946 */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2947 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
|
2948 if (s->height <= 400) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2949 return 1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2950 else if (s->height <= 800) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2951 return 2; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2952 else |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2953 return 4; |
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 |
1661 | 2956 int ff_h263_decode_mba(MpegEncContext *s) |
2957 { | |
2958 int i, mb_pos; | |
2959 | |
2960 for(i=0; i<6; i++){ | |
1670 | 2961 if(s->mb_num-1 <= ff_mba_max[i]) break; |
1661 | 2962 } |
2963 mb_pos= get_bits(&s->gb, ff_mba_length[i]); | |
2964 s->mb_x= mb_pos % s->mb_width; | |
2965 s->mb_y= mb_pos / s->mb_width; | |
2966 | |
2967 return mb_pos; | |
2968 } | |
2969 | |
2970 void ff_h263_encode_mba(MpegEncContext *s) | |
2971 { | |
2972 int i, mb_pos; | |
2973 | |
2974 for(i=0; i<6; i++){ | |
1670 | 2975 if(s->mb_num-1 <= ff_mba_max[i]) break; |
1661 | 2976 } |
2977 mb_pos= s->mb_x + s->mb_width*s->mb_y; | |
2978 put_bits(&s->pb, ff_mba_length[i], mb_pos); | |
2979 } | |
2980 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2981 /** |
1661 | 2982 * decodes the group of blocks header or slice header. |
6524 | 2983 * @return <0 if an error occurred |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2984 */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2985 static int h263_decode_gob_header(MpegEncContext *s) |
162 | 2986 { |
1661 | 2987 unsigned int val, gfid, gob_number; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2988 int left; |
2967 | 2989 |
162 | 2990 /* Check for GOB Start Code */ |
2991 val = show_bits(&s->gb, 16); | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2992 if(val) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2993 return -1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2994 |
162 | 2995 /* 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
|
2996 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
|
2997 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
|
2998 //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
|
2999 for(;left>13; left--){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3000 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
|
3001 } |
2967 | 3002 if(left<=13) |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3003 return -1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3004 |
1661 | 3005 if(s->h263_slice_structured){ |
3006 if(get_bits1(&s->gb)==0) | |
3007 return -1; | |
3008 | |
3009 ff_h263_decode_mba(s); | |
3010 | |
3011 if(s->mb_num > 1583) | |
3012 if(get_bits1(&s->gb)==0) | |
3013 return -1; | |
2967 | 3014 |
1661 | 3015 s->qscale = get_bits(&s->gb, 5); /* SQUANT */ |
3016 if(get_bits1(&s->gb)==0) | |
3017 return -1; | |
3018 gfid = get_bits(&s->gb, 2); /* GFID */ | |
3019 }else{ | |
3020 gob_number = get_bits(&s->gb, 5); /* GN */ | |
3021 s->mb_x= 0; | |
3022 s->mb_y= s->gob_index* gob_number; | |
3023 gfid = get_bits(&s->gb, 2); /* GFID */ | |
3024 s->qscale = get_bits(&s->gb, 5); /* GQUANT */ | |
3025 } | |
2967 | 3026 |
3027 if(s->mb_y >= s->mb_height) | |
1661 | 3028 return -1; |
3029 | |
2967 | 3030 if(s->qscale==0) |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3031 return -1; |
1644 | 3032 |
162 | 3033 return 0; |
3034 } | |
3035 | |
290 | 3036 static inline void memsetw(short *tab, int val, int n) |
3037 { | |
3038 int i; | |
3039 for(i=0;i<n;i++) | |
3040 tab[i] = val; | |
3041 } | |
3042 | |
8590 | 3043 #if CONFIG_ENCODERS |
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
|
3044 |
453 | 3045 void ff_mpeg4_init_partitions(MpegEncContext *s) |
3046 { | |
9431 | 3047 uint8_t *start= put_bits_ptr(&s->pb); |
1799 | 3048 uint8_t *end= s->pb.buf_end; |
3049 int size= end - start; | |
9259 | 3050 int pb_size = (((intptr_t)start + size/3)&(~3)) - (intptr_t)start; |
1912 | 3051 int tex_size= (size - 2*pb_size)&(~3); |
2967 | 3052 |
1799 | 3053 set_put_bits_buffer_size(&s->pb, pb_size); |
3054 init_put_bits(&s->tex_pb, start + pb_size , tex_size); | |
1910
5c21b165abf6
ensure that the bitstream buffers for encoding partitioned frames are aligned
michael
parents:
1896
diff
changeset
|
3055 init_put_bits(&s->pb2 , start + pb_size + tex_size, pb_size); |
453 | 3056 } |
3057 | |
3058 void ff_mpeg4_merge_partitions(MpegEncContext *s) | |
290 | 3059 { |
1786 | 3060 const int pb2_len = put_bits_count(&s->pb2 ); |
3061 const int tex_pb_len= put_bits_count(&s->tex_pb); | |
3062 const int bits= put_bits_count(&s->pb); | |
453 | 3063 |
6481 | 3064 if(s->pict_type==FF_I_TYPE){ |
453 | 3065 put_bits(&s->pb, 19, DC_MARKER); |
3066 s->misc_bits+=19 + pb2_len + bits - s->last_bits; | |
3067 s->i_tex_bits+= tex_pb_len; | |
3068 }else{ | |
3069 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
|
3070 s->misc_bits+=17 + pb2_len; |
453 | 3071 s->mv_bits+= bits - s->last_bits; |
3072 s->p_tex_bits+= tex_pb_len; | |
3073 } | |
3074 | |
3075 flush_put_bits(&s->pb2); | |
3076 flush_put_bits(&s->tex_pb); | |
3077 | |
1799 | 3078 set_put_bits_buffer_size(&s->pb, s->pb2.buf_end - s->pb.buf); |
3079 ff_copy_bits(&s->pb, s->pb2.buf , pb2_len); | |
3080 ff_copy_bits(&s->pb, s->tex_pb.buf, tex_pb_len); | |
1786 | 3081 s->last_bits= put_bits_count(&s->pb); |
453 | 3082 } |
3083 | |
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
|
3084 #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
|
3085 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3086 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
|
3087 switch(s->pict_type){ |
6481 | 3088 case FF_I_TYPE: |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3089 return 16; |
6481 | 3090 case FF_P_TYPE: |
3091 case FF_S_TYPE: | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3092 return s->f_code+15; |
6481 | 3093 case FF_B_TYPE: |
6655
22cca5d3173a
Implement FFMAX3(a,b,c) - maximum over three arguments.
voroshil
parents:
6524
diff
changeset
|
3094 return FFMAX3(s->f_code, s->b_code, 2) + 15; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3095 default: |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3096 return -1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3097 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3098 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3099 |
8590 | 3100 #if CONFIG_ENCODERS |
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
|
3101 |
453 | 3102 void ff_mpeg4_encode_video_packet_header(MpegEncContext *s) |
3103 { | |
3104 int mb_num_bits= av_log2(s->mb_num - 1) + 1; | |
3105 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3106 put_bits(&s->pb, ff_mpeg4_get_video_packet_prefix_length(s), 0); |
453 | 3107 put_bits(&s->pb, 1, 1); |
2967 | 3108 |
453 | 3109 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
|
3110 put_bits(&s->pb, s->quant_precision, s->qscale); |
453 | 3111 put_bits(&s->pb, 1, 0); /* no HEC */ |
3112 } | |
3113 | |
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
|
3114 #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
|
3115 |
453 | 3116 /** |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3117 * 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
|
3118 * @return 0 if not |
453 | 3119 */ |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3120 static inline int mpeg4_is_resync(MpegEncContext *s){ |
4161
f81bca10a740
100l for me, iam being to stupid to read the mpeg4 spec / eat stuffing mbs a the end of the picture
michael
parents:
4155
diff
changeset
|
3121 int bits_count= get_bits_count(&s->gb); |
f81bca10a740
100l for me, iam being to stupid to read the mpeg4 spec / eat stuffing mbs a the end of the picture
michael
parents:
4155
diff
changeset
|
3122 int v= show_bits(&s->gb, 16); |
2967 | 3123 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3124 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
|
3125 return 0; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3126 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3127 |
4161
f81bca10a740
100l for me, iam being to stupid to read the mpeg4 spec / eat stuffing mbs a the end of the picture
michael
parents:
4155
diff
changeset
|
3128 while(v<=0xFF){ |
6481 | 3129 if(s->pict_type==FF_B_TYPE || (v>>(8-s->pict_type)!=1) || s->partitioned_frame) |
4161
f81bca10a740
100l for me, iam being to stupid to read the mpeg4 spec / eat stuffing mbs a the end of the picture
michael
parents:
4155
diff
changeset
|
3130 break; |
f81bca10a740
100l for me, iam being to stupid to read the mpeg4 spec / eat stuffing mbs a the end of the picture
michael
parents:
4155
diff
changeset
|
3131 skip_bits(&s->gb, 8+s->pict_type); |
f81bca10a740
100l for me, iam being to stupid to read the mpeg4 spec / eat stuffing mbs a the end of the picture
michael
parents:
4155
diff
changeset
|
3132 bits_count+= 8+s->pict_type; |
f81bca10a740
100l for me, iam being to stupid to read the mpeg4 spec / eat stuffing mbs a the end of the picture
michael
parents:
4155
diff
changeset
|
3133 v= show_bits(&s->gb, 16); |
f81bca10a740
100l for me, iam being to stupid to read the mpeg4 spec / eat stuffing mbs a the end of the picture
michael
parents:
4155
diff
changeset
|
3134 } |
f81bca10a740
100l for me, iam being to stupid to read the mpeg4 spec / eat stuffing mbs a the end of the picture
michael
parents:
4155
diff
changeset
|
3135 |
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
|
3136 if(bits_count + 8 >= s->gb.size_in_bits){ |
4161
f81bca10a740
100l for me, iam being to stupid to read the mpeg4 spec / eat stuffing mbs a the end of the picture
michael
parents:
4155
diff
changeset
|
3137 v>>=8; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3138 v|= 0x7F >> (7-(bits_count&7)); |
2967 | 3139 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3140 if(v==0x7F) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3141 return 1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3142 }else{ |
4161
f81bca10a740
100l for me, iam being to stupid to read the mpeg4 spec / eat stuffing mbs a the end of the picture
michael
parents:
4155
diff
changeset
|
3143 if(v == ff_mpeg4_resync_prefix[bits_count&7]){ |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3144 int len; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3145 GetBitContext gb= s->gb; |
2967 | 3146 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3147 skip_bits(&s->gb, 1); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3148 align_get_bits(&s->gb); |
2967 | 3149 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3150 for(len=0; len<32; len++){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3151 if(get_bits1(&s->gb)) break; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3152 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3153 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3154 s->gb= gb; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3155 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3156 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
|
3157 return 1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3158 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3159 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3160 return 0; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3161 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3162 |
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 * decodes the next video packet. |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3165 * @return <0 if something went wrong |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3166 */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3167 static int mpeg4_decode_video_packet_header(MpegEncContext *s) |
453 | 3168 { |
290 | 3169 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
|
3170 int header_extension=0, mb_num, len; |
2967 | 3171 |
453 | 3172 /* 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
|
3173 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
|
3174 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3175 for(len=0; len<32; len++){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3176 if(get_bits1(&s->gb)) break; |
453 | 3177 } |
3178 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3179 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
|
3180 av_log(s->avctx, AV_LOG_ERROR, "marker does not match f_code\n"); |
453 | 3181 return -1; |
3182 } | |
2967 | 3183 |
453 | 3184 if(s->shape != RECT_SHAPE){ |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3185 header_extension= get_bits1(&s->gb); |
453 | 3186 //FIXME more stuff here |
3187 } | |
3188 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3189 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
|
3190 if(mb_num>=s->mb_num){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
3191 av_log(s->avctx, AV_LOG_ERROR, "illegal mb_num in video packet (%d %d) \n", mb_num, s->mb_num); |
453 | 3192 return -1; |
3193 } | |
6481 | 3194 if(s->pict_type == FF_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
|
3195 while(s->next_picture.mbskip_table[ s->mb_index2xy[ mb_num ] ]) mb_num++; |
6497 | 3196 if(mb_num >= s->mb_num) return -1; // slice contains just skipped MBs which where already decoded |
1176 | 3197 } |
2967 | 3198 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3199 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
|
3200 s->mb_y= mb_num / s->mb_width; |
453 | 3201 |
3202 if(s->shape != BIN_ONLY_SHAPE){ | |
2967 | 3203 int qscale= get_bits(&s->gb, s->quant_precision); |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3204 if(qscale) |
1644 | 3205 s->chroma_qscale=s->qscale= qscale; |
290 | 3206 } |
3207 | |
3208 if(s->shape == RECT_SHAPE){ | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3209 header_extension= get_bits1(&s->gb); |
290 | 3210 } |
3211 if(header_extension){ | |
453 | 3212 int time_increment; |
290 | 3213 int time_incr=0; |
453 | 3214 |
2967 | 3215 while (get_bits1(&s->gb) != 0) |
290 | 3216 time_incr++; |
3217 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3218 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
|
3219 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
|
3220 check_marker(&s->gb, "before vop_coding_type in video packed header"); |
2967 | 3221 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3222 skip_bits(&s->gb, 2); /* vop coding type */ |
290 | 3223 //FIXME not rect stuff here |
3224 | |
3225 if(s->shape != BIN_ONLY_SHAPE){ | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3226 skip_bits(&s->gb, 3); /* intra dc vlc threshold */ |
2646
c735e3e60ca7
Even More spelling errors. patch by (Kevin Baragona <kevinmb500 gawab com)
michael
parents:
2639
diff
changeset
|
3227 //FIXME don't just ignore everything |
6481 | 3228 if(s->pict_type == FF_S_TYPE && s->vol_sprite_usage==GMC_SPRITE){ |
1914 | 3229 mpeg4_decode_sprite_trajectory(s, &s->gb); |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
3230 av_log(s->avctx, AV_LOG_ERROR, "untested\n"); |
290 | 3231 } |
3232 | |
3233 //FIXME reduced res stuff here | |
2967 | 3234 |
6481 | 3235 if (s->pict_type != FF_I_TYPE) { |
2979 | 3236 int f_code = get_bits(&s->gb, 3); /* fcode_for */ |
660 | 3237 if(f_code==0){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
3238 av_log(s->avctx, AV_LOG_ERROR, "Error, video packet header damaged (f_code=0)\n"); |
290 | 3239 } |
3240 } | |
6481 | 3241 if (s->pict_type == FF_B_TYPE) { |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3242 int b_code = get_bits(&s->gb, 3); |
660 | 3243 if(b_code==0){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
3244 av_log(s->avctx, AV_LOG_ERROR, "Error, video packet header damaged (b_code=0)\n"); |
660 | 3245 } |
2967 | 3246 } |
290 | 3247 } |
3248 } | |
3249 //FIXME new-pred stuff | |
2967 | 3250 |
453 | 3251 //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)); |
3252 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3253 return 0; |
453 | 3254 } |
3255 | |
3256 void ff_mpeg4_clean_buffers(MpegEncContext *s) | |
3257 { | |
3258 int c_wrap, c_xy, l_wrap, l_xy; | |
290 | 3259 |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
3260 l_wrap= s->b8_stride; |
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
3261 l_xy= (2*s->mb_y-1)*l_wrap + s->mb_x*2 - 1; |
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
3262 c_wrap= s->mb_stride; |
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
3263 c_xy= (s->mb_y-1)*c_wrap + s->mb_x - 1; |
290 | 3264 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3265 #if 0 |
290 | 3266 /* clean DC */ |
453 | 3267 memsetw(s->dc_val[0] + l_xy, 1024, l_wrap*2+1); |
3268 memsetw(s->dc_val[1] + c_xy, 1024, c_wrap+1); | |
3269 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
|
3270 #endif |
290 | 3271 |
3272 /* clean AC */ | |
1064 | 3273 memset(s->ac_val[0] + l_xy, 0, (l_wrap*2+1)*16*sizeof(int16_t)); |
3274 memset(s->ac_val[1] + c_xy, 0, (c_wrap +1)*16*sizeof(int16_t)); | |
3275 memset(s->ac_val[2] + c_xy, 0, (c_wrap +1)*16*sizeof(int16_t)); | |
290 | 3276 |
3277 /* clean MV */ | |
2646
c735e3e60ca7
Even More spelling errors. patch by (Kevin Baragona <kevinmb500 gawab com)
michael
parents:
2639
diff
changeset
|
3278 // we can't clear the MVs as they might be needed by a b frame |
1064 | 3279 // memset(s->motion_val + l_xy, 0, (l_wrap*2+1)*2*sizeof(int16_t)); |
3280 // memset(s->motion_val, 0, 2*sizeof(int16_t)*(2 + s->mb_width*2)*(2 + s->mb_height*2)); | |
453 | 3281 s->last_mv[0][0][0]= |
3282 s->last_mv[0][0][1]= | |
3283 s->last_mv[1][0][0]= | |
3284 s->last_mv[1][0][1]= 0; | |
3285 } | |
3286 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3287 /** |
9024
2bf694251330
Add ff_h263_find_resync_marker() to find the bit position of the next resync_marker, if any.
michael
parents:
9008
diff
changeset
|
3288 * finds the next resync_marker |
2bf694251330
Add ff_h263_find_resync_marker() to find the bit position of the next resync_marker, if any.
michael
parents:
9008
diff
changeset
|
3289 * @param p pointer to buffer to scan |
2bf694251330
Add ff_h263_find_resync_marker() to find the bit position of the next resync_marker, if any.
michael
parents:
9008
diff
changeset
|
3290 * @param end pointer to the end of the buffer |
2bf694251330
Add ff_h263_find_resync_marker() to find the bit position of the next resync_marker, if any.
michael
parents:
9008
diff
changeset
|
3291 * @return pointer to the next resync_marker, or \p end if none was found |
2bf694251330
Add ff_h263_find_resync_marker() to find the bit position of the next resync_marker, if any.
michael
parents:
9008
diff
changeset
|
3292 */ |
2bf694251330
Add ff_h263_find_resync_marker() to find the bit position of the next resync_marker, if any.
michael
parents:
9008
diff
changeset
|
3293 const uint8_t *ff_h263_find_resync_marker(const uint8_t *restrict p, const uint8_t * restrict end) |
2bf694251330
Add ff_h263_find_resync_marker() to find the bit position of the next resync_marker, if any.
michael
parents:
9008
diff
changeset
|
3294 { |
2bf694251330
Add ff_h263_find_resync_marker() to find the bit position of the next resync_marker, if any.
michael
parents:
9008
diff
changeset
|
3295 assert(p < end); |
2bf694251330
Add ff_h263_find_resync_marker() to find the bit position of the next resync_marker, if any.
michael
parents:
9008
diff
changeset
|
3296 |
2bf694251330
Add ff_h263_find_resync_marker() to find the bit position of the next resync_marker, if any.
michael
parents:
9008
diff
changeset
|
3297 end-=2; |
2bf694251330
Add ff_h263_find_resync_marker() to find the bit position of the next resync_marker, if any.
michael
parents:
9008
diff
changeset
|
3298 p++; |
2bf694251330
Add ff_h263_find_resync_marker() to find the bit position of the next resync_marker, if any.
michael
parents:
9008
diff
changeset
|
3299 for(;p<end; p+=2){ |
2bf694251330
Add ff_h263_find_resync_marker() to find the bit position of the next resync_marker, if any.
michael
parents:
9008
diff
changeset
|
3300 if(!*p){ |
2bf694251330
Add ff_h263_find_resync_marker() to find the bit position of the next resync_marker, if any.
michael
parents:
9008
diff
changeset
|
3301 if (!p[-1] && p[1]) return p - 1; |
2bf694251330
Add ff_h263_find_resync_marker() to find the bit position of the next resync_marker, if any.
michael
parents:
9008
diff
changeset
|
3302 else if(!p[ 1] && p[2]) return p; |
2bf694251330
Add ff_h263_find_resync_marker() to find the bit position of the next resync_marker, if any.
michael
parents:
9008
diff
changeset
|
3303 } |
2bf694251330
Add ff_h263_find_resync_marker() to find the bit position of the next resync_marker, if any.
michael
parents:
9008
diff
changeset
|
3304 } |
2bf694251330
Add ff_h263_find_resync_marker() to find the bit position of the next resync_marker, if any.
michael
parents:
9008
diff
changeset
|
3305 return end+2; |
2bf694251330
Add ff_h263_find_resync_marker() to find the bit position of the next resync_marker, if any.
michael
parents:
9008
diff
changeset
|
3306 } |
2bf694251330
Add ff_h263_find_resync_marker() to find the bit position of the next resync_marker, if any.
michael
parents:
9008
diff
changeset
|
3307 |
2bf694251330
Add ff_h263_find_resync_marker() to find the bit position of the next resync_marker, if any.
michael
parents:
9008
diff
changeset
|
3308 /** |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3309 * decodes the group of blocks / video packet header. |
8691
25aa5388fa97
Make ff_h263_resync() return the bit position of the resync_marker or
benoit
parents:
8690
diff
changeset
|
3310 * @return bit position of the resync_marker, or <0 if none was found |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3311 */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3312 int ff_h263_resync(MpegEncContext *s){ |
8691
25aa5388fa97
Make ff_h263_resync() return the bit position of the resync_marker or
benoit
parents:
8690
diff
changeset
|
3313 int left, pos, ret; |
2967 | 3314 |
1521 | 3315 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
|
3316 skip_bits1(&s->gb); |
1521 | 3317 align_get_bits(&s->gb); |
3318 } | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3319 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3320 if(show_bits(&s->gb, 16)==0){ |
8691
25aa5388fa97
Make ff_h263_resync() return the bit position of the resync_marker or
benoit
parents:
8690
diff
changeset
|
3321 pos= get_bits_count(&s->gb); |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3322 if(s->codec_id==CODEC_ID_MPEG4) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3323 ret= mpeg4_decode_video_packet_header(s); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3324 else |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3325 ret= h263_decode_gob_header(s); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3326 if(ret>=0) |
8691
25aa5388fa97
Make ff_h263_resync() return the bit position of the resync_marker or
benoit
parents:
8690
diff
changeset
|
3327 return pos; |
453 | 3328 } |
5129 | 3329 //OK, it's not where it is supposed to be ... |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3330 s->gb= s->last_resync_gb; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3331 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
|
3332 left= s->gb.size_in_bits - get_bits_count(&s->gb); |
2967 | 3333 |
3334 for(;left>16+1+5+5; left-=8){ | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3335 if(show_bits(&s->gb, 16)==0){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3336 GetBitContext bak= s->gb; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3337 |
8691
25aa5388fa97
Make ff_h263_resync() return the bit position of the resync_marker or
benoit
parents:
8690
diff
changeset
|
3338 pos= get_bits_count(&s->gb); |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3339 if(s->codec_id==CODEC_ID_MPEG4) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3340 ret= mpeg4_decode_video_packet_header(s); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3341 else |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3342 ret= h263_decode_gob_header(s); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3343 if(ret>=0) |
8691
25aa5388fa97
Make ff_h263_resync() return the bit position of the resync_marker or
benoit
parents:
8690
diff
changeset
|
3344 return pos; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3345 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3346 s->gb= bak; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3347 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3348 skip_bits(&s->gb, 8); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3349 } |
2967 | 3350 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3351 return -1; |
453 | 3352 } |
3353 | |
3354 /** | |
1034 | 3355 * gets the average motion vector for a GMC MB. |
753 | 3356 * @param n either 0 for the x component or 1 for y |
3357 * @returns the average MV for a GMC MB | |
3358 */ | |
3359 static inline int get_amv(MpegEncContext *s, int n){ | |
3360 int x, y, mb_v, sum, dx, dy, shift; | |
3361 int len = 1 << (s->f_code + 4); | |
3362 const int a= s->sprite_warping_accuracy; | |
2967 | 3363 |
1997 | 3364 if(s->workaround_bugs & FF_BUG_AMV) |
3365 len >>= s->quarter_sample; | |
753 | 3366 |
3367 if(s->real_sprite_warping_points==1){ | |
3368 if(s->divx_version==500 && s->divx_build==413) | |
3369 sum= s->sprite_offset[0][n] / (1<<(a - s->quarter_sample)); | |
3370 else | |
3371 sum= RSHIFT(s->sprite_offset[0][n]<<s->quarter_sample, a); | |
3372 }else{ | |
3373 dx= s->sprite_delta[n][0]; | |
3374 dy= s->sprite_delta[n][1]; | |
3375 shift= s->sprite_shift[0]; | |
3376 if(n) dy -= 1<<(shift + a + 1); | |
3377 else dx -= 1<<(shift + a + 1); | |
3378 mb_v= s->sprite_offset[0][n] + dx*s->mb_x*16 + dy*s->mb_y*16; | |
3379 | |
3380 sum=0; | |
3381 for(y=0; y<16; y++){ | |
3382 int v; | |
2967 | 3383 |
753 | 3384 v= mb_v + dy*y; |
3385 //XXX FIXME optimize | |
3386 for(x=0; x<16; x++){ | |
3387 sum+= v>>shift; | |
3388 v+= dx; | |
3389 } | |
3390 } | |
999
74dc4105e147
average motion vector rounding like the reference says and not what the standard says
michaelni
parents:
953
diff
changeset
|
3391 sum= RSHIFT(sum, a+8-s->quarter_sample); |
753 | 3392 } |
3393 | |
3394 if (sum < -len) sum= -len; | |
3395 else if (sum >= len) sum= len-1; | |
3396 | |
3397 return sum; | |
3398 } | |
3399 | |
3400 /** | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3401 * decodes first partition. |
6524 | 3402 * @return number of MBs decoded or <0 if an error occurred |
453 | 3403 */ |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3404 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
|
3405 int mb_num; |
1064 | 3406 static const int8_t quant_tab[4] = { -1, -2, 1, 2 }; |
2967 | 3407 |
453 | 3408 /* decode first partition */ |
3409 mb_num=0; | |
290 | 3410 s->first_slice_line=1; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3411 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
|
3412 ff_init_block_index(s); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3413 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
|
3414 const int xy= s->mb_x + s->mb_y*s->mb_stride; |
453 | 3415 int cbpc; |
3416 int dir=0; | |
2967 | 3417 |
453 | 3418 mb_num++; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3419 ff_update_block_index(s); |
453 | 3420 if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1) |
3421 s->first_slice_line=0; | |
2967 | 3422 |
6481 | 3423 if(s->pict_type==FF_I_TYPE){ |
453 | 3424 int i; |
3425 | |
1482 | 3426 do{ |
1873 | 3427 if(show_bits_long(&s->gb, 19)==DC_MARKER){ |
3428 return mb_num-1; | |
3429 } | |
3430 | |
1482 | 3431 cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2); |
3432 if (cbpc < 0){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
3433 av_log(s->avctx, AV_LOG_ERROR, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y); |
1482 | 3434 return -1; |
3435 } | |
3436 }while(cbpc == 8); | |
2967 | 3437 |
453 | 3438 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
|
3439 s->current_picture.mb_type[xy]= MB_TYPE_INTRA; |
453 | 3440 s->mb_intra = 1; |
3441 | |
3442 if(cbpc & 4) { | |
1652 | 3443 ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]); |
453 | 3444 } |
903 | 3445 s->current_picture.qscale_table[xy]= s->qscale; |
453 | 3446 |
3447 s->mbintra_table[xy]= 1; | |
3448 for(i=0; i<6; i++){ | |
3449 int dc_pred_dir; | |
2967 | 3450 int dc= mpeg4_decode_dc(s, i, &dc_pred_dir); |
453 | 3451 if(dc < 0){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
3452 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
|
3453 return -1; |
453 | 3454 } |
3455 dir<<=1; | |
3456 if(dc_pred_dir) dir|=1; | |
3457 } | |
3458 s->pred_dir_table[xy]= dir; | |
3459 }else{ /* P/S_TYPE */ | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3460 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
|
3461 int16_t * const mot_val= s->current_picture.motion_val[0][s->block_index[0]]; |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
3462 const int stride= s->b8_stride*2; |
453 | 3463 |
1873 | 3464 try_again: |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3465 bits= show_bits(&s->gb, 17); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3466 if(bits==MOTION_MARKER){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3467 return mb_num-1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3468 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3469 skip_bits1(&s->gb); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3470 if(bits&0x10000){ |
453 | 3471 /* skip mb */ |
6481 | 3472 if(s->pict_type==FF_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
|
3473 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0; |
753 | 3474 mx= get_amv(s, 0); |
3475 my= get_amv(s, 1); | |
453 | 3476 }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
|
3477 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0; |
753 | 3478 mx=my=0; |
453 | 3479 } |
3480 mot_val[0 ]= mot_val[2 ]= | |
3481 mot_val[0+stride]= mot_val[2+stride]= mx; | |
3482 mot_val[1 ]= mot_val[3 ]= | |
3483 mot_val[1+stride]= mot_val[3+stride]= my; | |
3484 | |
3485 if(s->mbintra_table[xy]) | |
3486 ff_clean_intra_table_entries(s); | |
3487 continue; | |
3488 } | |
1482 | 3489 |
544 | 3490 cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2); |
453 | 3491 if (cbpc < 0){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
3492 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
|
3493 return -1; |
453 | 3494 } |
1873 | 3495 if(cbpc == 20) |
3496 goto try_again; | |
1482 | 3497 |
453 | 3498 s->cbp_table[xy]= cbpc&(8+3); //8 is dquant |
2967 | 3499 |
453 | 3500 s->mb_intra = ((cbpc & 4) != 0); |
2967 | 3501 |
453 | 3502 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
|
3503 s->current_picture.mb_type[xy]= MB_TYPE_INTRA; |
453 | 3504 s->mbintra_table[xy]= 1; |
2967 | 3505 mot_val[0 ]= mot_val[2 ]= |
453 | 3506 mot_val[0+stride]= mot_val[2+stride]= 0; |
3507 mot_val[1 ]= mot_val[3 ]= | |
3508 mot_val[1+stride]= mot_val[3+stride]= 0; | |
3509 }else{ | |
3510 if(s->mbintra_table[xy]) | |
3511 ff_clean_intra_table_entries(s); | |
3512 | |
6481 | 3513 if(s->pict_type==FF_S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0) |
453 | 3514 s->mcsel= get_bits1(&s->gb); |
3515 else s->mcsel= 0; | |
2967 | 3516 |
453 | 3517 if ((cbpc & 16) == 0) { |
3518 /* 16x16 motion prediction */ | |
3519 | |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
3520 h263_pred_motion(s, 0, 0, &pred_x, &pred_y); |
753 | 3521 if(!s->mcsel){ |
3522 mx = h263_decode_motion(s, pred_x, s->f_code); | |
3523 if (mx >= 0xffff) | |
3524 return -1; | |
3525 | |
3526 my = h263_decode_motion(s, pred_y, s->f_code); | |
3527 if (my >= 0xffff) | |
3528 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
|
3529 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0; |
753 | 3530 } else { |
3531 mx = get_amv(s, 0); | |
3532 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
|
3533 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0; |
453 | 3534 } |
753 | 3535 |
453 | 3536 mot_val[0 ]= mot_val[2 ] = |
3537 mot_val[0+stride]= mot_val[2+stride]= mx; | |
3538 mot_val[1 ]= mot_val[3 ]= | |
3539 mot_val[1+stride]= mot_val[3+stride]= my; | |
3540 } else { | |
3541 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
|
3542 s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0; |
453 | 3543 for(i=0;i<4;i++) { |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
3544 int16_t *mot_val= h263_pred_motion(s, i, 0, &pred_x, &pred_y); |
453 | 3545 mx = h263_decode_motion(s, pred_x, s->f_code); |
3546 if (mx >= 0xffff) | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3547 return -1; |
2967 | 3548 |
453 | 3549 my = h263_decode_motion(s, pred_y, s->f_code); |
3550 if (my >= 0xffff) | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3551 return -1; |
453 | 3552 mot_val[0] = mx; |
3553 mot_val[1] = my; | |
3554 } | |
3555 } | |
3556 } | |
3557 } | |
3558 } | |
3559 s->mb_x= 0; | |
3560 } | |
3561 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3562 return mb_num; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3563 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3564 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3565 /** |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3566 * decode second partition. |
6524 | 3567 * @return <0 if an error occurred |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3568 */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3569 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
|
3570 int mb_num=0; |
1064 | 3571 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
|
3572 |
453 | 3573 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
|
3574 s->first_slice_line=1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3575 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
|
3576 ff_init_block_index(s); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3577 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
|
3578 const int xy= s->mb_x + s->mb_y*s->mb_stride; |
453 | 3579 |
3580 mb_num++; | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3581 ff_update_block_index(s); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3582 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
|
3583 s->first_slice_line=0; |
2967 | 3584 |
6481 | 3585 if(s->pict_type==FF_I_TYPE){ |
453 | 3586 int ac_pred= get_bits1(&s->gb); |
544 | 3587 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1); |
453 | 3588 if(cbpy<0){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
3589 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
|
3590 return -1; |
453 | 3591 } |
2967 | 3592 |
453 | 3593 s->cbp_table[xy]|= cbpy<<2; |
2967 | 3594 s->current_picture.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED; |
453 | 3595 }else{ /* P || S_TYPE */ |
2967 | 3596 if(IS_INTRA(s->current_picture.mb_type[xy])){ |
453 | 3597 int dir=0,i; |
3598 int ac_pred = get_bits1(&s->gb); | |
544 | 3599 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1); |
453 | 3600 |
3601 if(cbpy<0){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
3602 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
|
3603 return -1; |
453 | 3604 } |
2967 | 3605 |
453 | 3606 if(s->cbp_table[xy] & 8) { |
1652 | 3607 ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]); |
453 | 3608 } |
903 | 3609 s->current_picture.qscale_table[xy]= s->qscale; |
453 | 3610 |
3611 for(i=0; i<6; i++){ | |
3612 int dc_pred_dir; | |
2967 | 3613 int dc= mpeg4_decode_dc(s, i, &dc_pred_dir); |
453 | 3614 if(dc < 0){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
3615 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
|
3616 return -1; |
453 | 3617 } |
3618 dir<<=1; | |
3619 if(dc_pred_dir) dir|=1; | |
3620 } | |
3621 s->cbp_table[xy]&= 3; //remove dquant | |
3622 s->cbp_table[xy]|= cbpy<<2; | |
2967 | 3623 s->current_picture.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED; |
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
|
3624 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
|
3625 }else if(IS_SKIP(s->current_picture.mb_type[xy])){ |
903 | 3626 s->current_picture.qscale_table[xy]= s->qscale; |
453 | 3627 s->cbp_table[xy]= 0; |
3628 }else{ | |
544 | 3629 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1); |
453 | 3630 |
3631 if(cbpy<0){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
3632 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
|
3633 return -1; |
453 | 3634 } |
2967 | 3635 |
453 | 3636 if(s->cbp_table[xy] & 8) { |
1652 | 3637 ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]); |
453 | 3638 } |
903 | 3639 s->current_picture.qscale_table[xy]= s->qscale; |
453 | 3640 |
3641 s->cbp_table[xy]&= 3; //remove dquant | |
3642 s->cbp_table[xy]|= (cbpy^0xf)<<2; | |
3643 } | |
3644 } | |
3645 } | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3646 if(mb_num >= mb_count) return 0; |
453 | 3647 s->mb_x= 0; |
3648 } | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3649 return 0; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3650 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3651 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3652 /** |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3653 * decodes the first & second partition |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3654 * @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
|
3655 */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3656 int ff_mpeg4_decode_partitions(MpegEncContext *s) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3657 { |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3658 int mb_num; |
6481 | 3659 const int part_a_error= s->pict_type==FF_I_TYPE ? (DC_ERROR|MV_ERROR) : MV_ERROR; |
3660 const int part_a_end = s->pict_type==FF_I_TYPE ? (DC_END |MV_END) : MV_END; | |
2967 | 3661 |
3662 mb_num= mpeg4_decode_partition_a(s); | |
1144 | 3663 if(mb_num<0){ |
3664 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
|
3665 return -1; |
1144 | 3666 } |
2967 | 3667 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3668 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
|
3669 av_log(s->avctx, AV_LOG_ERROR, "slice below monitor ...\n"); |
1144 | 3670 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
|
3671 return -1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3672 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3673 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3674 s->mb_num_left= mb_num; |
2967 | 3675 |
6481 | 3676 if(s->pict_type==FF_I_TYPE){ |
1873 | 3677 while(show_bits(&s->gb, 9) == 1) |
3678 skip_bits(&s->gb, 9); | |
1257 | 3679 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
|
3680 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
|
3681 return -1; |
1144 | 3682 } |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3683 }else{ |
1873 | 3684 while(show_bits(&s->gb, 10) == 1) |
3685 skip_bits(&s->gb, 10); | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3686 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
|
3687 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
|
3688 return -1; |
1144 | 3689 } |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3690 } |
1144 | 3691 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, part_a_end); |
2967 | 3692 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3693 if( mpeg4_decode_partition_b(s, mb_num) < 0){ |
6481 | 3694 if(s->pict_type==FF_P_TYPE) |
1144 | 3695 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
|
3696 return -1; |
1144 | 3697 }else{ |
6481 | 3698 if(s->pict_type==FF_P_TYPE) |
1144 | 3699 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
|
3700 } |
453 | 3701 |
2967 | 3702 return 0; |
453 | 3703 } |
3704 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3705 /** |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3706 * decode partition C of one MB. |
6524 | 3707 * @return <0 if an error occurred |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3708 */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3709 static int mpeg4_decode_partitioned_mb(MpegEncContext *s, DCTELEM block[6][64]) |
453 | 3710 { |
3711 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
|
3712 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
|
3713 |
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
|
3714 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
|
3715 cbp = s->cbp_table[xy]; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3716 |
3282 | 3717 s->use_intra_dc_vlc= s->qscale < s->intra_dc_threshold; |
3718 | |
903 | 3719 if(s->current_picture.qscale_table[xy] != s->qscale){ |
1652 | 3720 ff_set_qscale(s, s->current_picture.qscale_table[xy] ); |
453 | 3721 } |
2967 | 3722 |
6481 | 3723 if (s->pict_type == FF_P_TYPE || s->pict_type==FF_S_TYPE) { |
453 | 3724 int i; |
3725 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
|
3726 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
|
3727 s->mv[0][i][1] = s->current_picture.motion_val[0][ s->block_index[i] ][1]; |
453 | 3728 } |
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
|
3729 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
|
3730 |
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
|
3731 if (IS_SKIP(mb_type)) { |
453 | 3732 /* skip mb */ |
3733 for(i=0;i<6;i++) | |
3734 s->block_last_index[i] = -1; | |
3735 s->mv_dir = MV_DIR_FORWARD; | |
3736 s->mv_type = MV_TYPE_16X16; | |
6481 | 3737 if(s->pict_type==FF_S_TYPE && s->vol_sprite_usage==GMC_SPRITE){ |
453 | 3738 s->mcsel=1; |
2628
511e3afc43e1
Ministry of English Composition, reporting for duty (and the word is "skipped", not "skiped"; "skiped" would rhyme with "hyped")
melanson
parents:
2615
diff
changeset
|
3739 s->mb_skipped = 0; |
453 | 3740 }else{ |
3741 s->mcsel=0; | |
2628
511e3afc43e1
Ministry of English Composition, reporting for duty (and the word is "skipped", not "skiped"; "skiped" would rhyme with "hyped")
melanson
parents:
2615
diff
changeset
|
3742 s->mb_skipped = 1; |
453 | 3743 } |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3744 }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
|
3745 s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]); |
453 | 3746 }else if(!s->mb_intra){ |
3747 // s->mcsel= 0; //FIXME do we need to init that | |
2967 | 3748 |
453 | 3749 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
|
3750 if (IS_8X8(mb_type)) { |
453 | 3751 s->mv_type = MV_TYPE_8X8; |
3752 } else { | |
3753 s->mv_type = MV_TYPE_16X16; | |
3754 } | |
3755 } | |
3756 } else { /* I-Frame */ | |
3757 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
|
3758 s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]); |
1132 | 3759 } |
3760 | |
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
|
3761 if (!IS_SKIP(mb_type)) { |
1132 | 3762 int i; |
2632 | 3763 s->dsp.clear_blocks(s->block[0]); |
453 | 3764 /* decode each block */ |
3765 for (i = 0; i < 6; i++) { | |
1132 | 3766 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
|
3767 av_log(s->avctx, AV_LOG_ERROR, "texture corrupted at %d %d %d\n", s->mb_x, s->mb_y, s->mb_intra); |
453 | 3768 return -1; |
3769 } | |
718 | 3770 cbp+=cbp; |
453 | 3771 } |
3772 } | |
290 | 3773 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3774 /* per-MB end of slice check */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3775 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3776 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
|
3777 //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
|
3778 if(mpeg4_is_resync(s)) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3779 return SLICE_END; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3780 else |
2967 | 3781 return SLICE_NOEND; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3782 }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
|
3783 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
|
3784 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
|
3785 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
|
3786 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
|
3787 } |
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
|
3788 return SLICE_OK; |
619
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3789 } |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3790 } |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3791 |
1633 | 3792 /** |
3793 * read the next MVs for OBMC. yes this is a ugly hack, feel free to send a patch :) | |
3794 */ | |
3795 static void preview_obmc(MpegEncContext *s){ | |
3796 GetBitContext gb= s->gb; | |
2967 | 3797 |
1633 | 3798 int cbpc, i, pred_x, pred_y, mx, my; |
3799 int16_t *mot_val; | |
3800 const int xy= s->mb_x + 1 + s->mb_y * s->mb_stride; | |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
3801 const int stride= s->b8_stride*2; |
2967 | 3802 |
1633 | 3803 for(i=0; i<4; i++) |
3804 s->block_index[i]+= 2; | |
3805 for(i=4; i<6; i++) | |
3806 s->block_index[i]+= 1; | |
3807 s->mb_x++; | |
2967 | 3808 |
6481 | 3809 assert(s->pict_type == FF_P_TYPE); |
1633 | 3810 |
3811 do{ | |
3812 if (get_bits1(&s->gb)) { | |
3813 /* 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
|
3814 mot_val = s->current_picture.motion_val[0][ s->block_index[0] ]; |
2967 | 3815 mot_val[0 ]= mot_val[2 ]= |
1633 | 3816 mot_val[0+stride]= mot_val[2+stride]= 0; |
3817 mot_val[1 ]= mot_val[3 ]= | |
3818 mot_val[1+stride]= mot_val[3+stride]= 0; | |
2967 | 3819 |
1633 | 3820 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0; |
3821 goto end; | |
3822 } | |
3823 cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2); | |
3824 }while(cbpc == 20); | |
2967 | 3825 |
1633 | 3826 if(cbpc & 4){ |
3827 s->current_picture.mb_type[xy]= MB_TYPE_INTRA; | |
3828 }else{ | |
3829 get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1); | |
3830 if (cbpc & 8) { | |
1656 | 3831 if(s->modified_quant){ |
3832 if(get_bits1(&s->gb)) skip_bits(&s->gb, 1); | |
3833 else skip_bits(&s->gb, 5); | |
3834 }else | |
3835 skip_bits(&s->gb, 2); | |
1633 | 3836 } |
2967 | 3837 |
1633 | 3838 if ((cbpc & 16) == 0) { |
2967 | 3839 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0; |
1633 | 3840 /* 16x16 motion prediction */ |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
3841 mot_val= h263_pred_motion(s, 0, 0, &pred_x, &pred_y); |
1633 | 3842 if (s->umvplus) |
3843 mx = h263p_decode_umotion(s, pred_x); | |
3844 else | |
1655 | 3845 mx = h263_decode_motion(s, pred_x, 1); |
2967 | 3846 |
1633 | 3847 if (s->umvplus) |
3848 my = h263p_decode_umotion(s, pred_y); | |
3849 else | |
1655 | 3850 my = h263_decode_motion(s, pred_y, 1); |
2967 | 3851 |
3852 mot_val[0 ]= mot_val[2 ]= | |
1633 | 3853 mot_val[0+stride]= mot_val[2+stride]= mx; |
3854 mot_val[1 ]= mot_val[3 ]= | |
3855 mot_val[1+stride]= mot_val[3+stride]= my; | |
3856 } else { | |
2967 | 3857 s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0; |
1633 | 3858 for(i=0;i<4;i++) { |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
3859 mot_val = h263_pred_motion(s, i, 0, &pred_x, &pred_y); |
1633 | 3860 if (s->umvplus) |
3861 mx = h263p_decode_umotion(s, pred_x); | |
3862 else | |
1655 | 3863 mx = h263_decode_motion(s, pred_x, 1); |
2967 | 3864 |
1633 | 3865 if (s->umvplus) |
3866 my = h263p_decode_umotion(s, pred_y); | |
2967 | 3867 else |
1655 | 3868 my = h263_decode_motion(s, pred_y, 1); |
1633 | 3869 if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1) |
3870 skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */ | |
3871 mot_val[0] = mx; | |
3872 mot_val[1] = my; | |
3873 } | |
3874 } | |
3875 } | |
3876 end: | |
2967 | 3877 |
1633 | 3878 for(i=0; i<4; i++) |
3879 s->block_index[i]-= 2; | |
3880 for(i=4; i<6; i++) | |
3881 s->block_index[i]-= 1; | |
3882 s->mb_x--; | |
3883 | |
3884 s->gb= gb; | |
3885 } | |
3886 | |
1656 | 3887 static void h263_decode_dquant(MpegEncContext *s){ |
3888 static const int8_t quant_tab[4] = { -1, -2, 1, 2 }; | |
3889 | |
3890 if(s->modified_quant){ | |
3891 if(get_bits1(&s->gb)) | |
3892 s->qscale= modified_quant_tab[get_bits1(&s->gb)][ s->qscale ]; | |
3893 else | |
3894 s->qscale= get_bits(&s->gb, 5); | |
3895 }else | |
3896 s->qscale += quant_tab[get_bits(&s->gb, 2)]; | |
3897 ff_set_qscale(s, s->qscale); | |
3898 } | |
3899 | |
9103
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
3900 static int h263_skip_b_part(MpegEncContext *s, int cbp) |
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
3901 { |
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
3902 DECLARE_ALIGNED(16, DCTELEM, dblock[64]); |
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
3903 int i, mbi; |
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
3904 |
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
3905 /* we have to set s->mb_intra to zero to decode B-part of PB-frame correctly |
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
3906 * but real value should be restored in order to be used later (in OBMC condition) |
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
3907 */ |
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
3908 mbi = s->mb_intra; |
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
3909 s->mb_intra = 0; |
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
3910 for (i = 0; i < 6; i++) { |
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
3911 if (h263_decode_block(s, dblock, i, cbp&32) < 0) |
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
3912 return -1; |
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
3913 cbp+=cbp; |
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
3914 } |
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
3915 s->mb_intra = mbi; |
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
3916 return 0; |
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
3917 } |
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
3918 |
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
3919 static int h263_get_modb(GetBitContext *gb, int pb_frame, int *cbpb) |
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
3920 { |
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
3921 int c, mv = 1; |
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
3922 |
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
3923 if (pb_frame < 3) { // h.263 Annex G and i263 PB-frame |
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
3924 c = get_bits1(gb); |
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
3925 if (pb_frame == 2 && c) |
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
3926 mv = !get_bits1(gb); |
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
3927 } else { // h.263 Annex M improved PB-frame |
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
3928 mv = get_unary(gb, 0, 4) + 1; |
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
3929 c = mv & 1; |
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
3930 mv = !!(mv & 2); |
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
3931 } |
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
3932 if(c) |
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
3933 *cbpb = get_bits(gb, 6); |
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
3934 return mv; |
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
3935 } |
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
3936 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3937 int ff_h263_decode_mb(MpegEncContext *s, |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3938 DCTELEM block[6][64]) |
0 | 3939 { |
3940 int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant; | |
1064 | 3941 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
|
3942 const int xy= s->mb_x + s->mb_y * s->mb_stride; |
9103
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
3943 int cbpb = 0, pb_mv_count = 0; |
2967 | 3944 |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3945 assert(!s->h263_pred); |
2967 | 3946 |
6481 | 3947 if (s->pict_type == FF_P_TYPE) { |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3948 do{ |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3949 if (get_bits1(&s->gb)) { |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3950 /* skip mb */ |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3951 s->mb_intra = 0; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3952 for(i=0;i<6;i++) |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3953 s->block_last_index[i] = -1; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3954 s->mv_dir = MV_DIR_FORWARD; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3955 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
|
3956 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0; |
255 | 3957 s->mv[0][0][0] = 0; |
3958 s->mv[0][0][1] = 0; | |
2628
511e3afc43e1
Ministry of English Composition, reporting for duty (and the word is "skipped", not "skiped"; "skiped" would rhyme with "hyped")
melanson
parents:
2615
diff
changeset
|
3959 s->mb_skipped = !(s->obmc | s->loop_filter); |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3960 goto end; |
255 | 3961 } |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3962 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
|
3963 //fprintf(stderr, "\tCBPC: %d", cbpc); |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3964 if (cbpc < 0){ |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3965 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
|
3966 return -1; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3967 } |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3968 }while(cbpc == 20); |
2967 | 3969 |
2632 | 3970 s->dsp.clear_blocks(s->block[0]); |
2967 | 3971 |
0 | 3972 dquant = cbpc & 8; |
3973 s->mb_intra = ((cbpc & 4) != 0); | |
262 | 3974 if (s->mb_intra) goto intra; |
2967 | 3975 |
9103
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
3976 if(s->pb_frame && get_bits1(&s->gb)) |
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
3977 pb_mv_count = h263_get_modb(&s->gb, s->pb_frame, &cbpb); |
544 | 3978 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1); |
2967 | 3979 |
1637 | 3980 if(s->alt_inter_vlc==0 || (cbpc & 3)!=3) |
3981 cbpy ^= 0xF; | |
2967 | 3982 |
1637 | 3983 cbp = (cbpc & 3) | (cbpy << 2); |
0 | 3984 if (dquant) { |
1656 | 3985 h263_decode_dquant(s); |
0 | 3986 } |
2967 | 3987 |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3988 s->mv_dir = MV_DIR_FORWARD; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3989 if ((cbpc & 16) == 0) { |
2967 | 3990 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0; |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3991 /* 16x16 motion prediction */ |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3992 s->mv_type = MV_TYPE_16X16; |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
3993 h263_pred_motion(s, 0, 0, &pred_x, &pred_y); |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3994 if (s->umvplus) |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3995 mx = h263p_decode_umotion(s, pred_x); |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3996 else |
1655 | 3997 mx = h263_decode_motion(s, pred_x, 1); |
2967 | 3998 |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3999 if (mx >= 0xffff) |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4000 return -1; |
2967 | 4001 |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4002 if (s->umvplus) |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4003 my = h263p_decode_umotion(s, pred_y); |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4004 else |
1655 | 4005 my = h263_decode_motion(s, pred_y, 1); |
2967 | 4006 |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4007 if (my >= 0xffff) |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4008 return -1; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4009 s->mv[0][0][0] = mx; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4010 s->mv[0][0][1] = my; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4011 |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4012 if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1) |
2967 | 4013 skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */ |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4014 } else { |
2967 | 4015 s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0; |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4016 s->mv_type = MV_TYPE_8X8; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4017 for(i=0;i<4;i++) { |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
4018 mot_val = h263_pred_motion(s, i, 0, &pred_x, &pred_y); |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4019 if (s->umvplus) |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4020 mx = h263p_decode_umotion(s, pred_x); |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4021 else |
1655 | 4022 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
|
4023 if (mx >= 0xffff) |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4024 return -1; |
2967 | 4025 |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4026 if (s->umvplus) |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4027 my = h263p_decode_umotion(s, pred_y); |
2967 | 4028 else |
1655 | 4029 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
|
4030 if (my >= 0xffff) |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4031 return -1; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4032 s->mv[0][i][0] = mx; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4033 s->mv[0][i][1] = my; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4034 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
|
4035 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
|
4036 mot_val[0] = mx; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4037 mot_val[1] = my; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4038 } |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4039 } |
6481 | 4040 } else if(s->pict_type==FF_B_TYPE) { |
1655 | 4041 int mb_type; |
4042 const int stride= s->b8_stride; | |
1701 | 4043 int16_t *mot_val0 = s->current_picture.motion_val[0][ 2*(s->mb_x + s->mb_y*stride) ]; |
4044 int16_t *mot_val1 = s->current_picture.motion_val[1][ 2*(s->mb_x + s->mb_y*stride) ]; | |
1655 | 4045 // const int mv_xy= s->mb_x + 1 + s->mb_y * s->mb_stride; |
4046 | |
2967 | 4047 //FIXME ugly |
4048 mot_val0[0 ]= mot_val0[2 ]= mot_val0[0+2*stride]= mot_val0[2+2*stride]= | |
4049 mot_val0[1 ]= mot_val0[3 ]= mot_val0[1+2*stride]= mot_val0[3+2*stride]= | |
4050 mot_val1[0 ]= mot_val1[2 ]= mot_val1[0+2*stride]= mot_val1[2+2*stride]= | |
1701 | 4051 mot_val1[1 ]= mot_val1[3 ]= mot_val1[1+2*stride]= mot_val1[3+2*stride]= 0; |
1655 | 4052 |
4053 do{ | |
4054 mb_type= get_vlc2(&s->gb, h263_mbtype_b_vlc.table, H263_MBTYPE_B_VLC_BITS, 2); | |
4055 if (mb_type < 0){ | |
4056 av_log(s->avctx, AV_LOG_ERROR, "b mb_type damaged at %d %d\n", s->mb_x, s->mb_y); | |
4057 return -1; | |
4058 } | |
4059 | |
4060 mb_type= h263_mb_type_b_map[ mb_type ]; | |
4061 }while(!mb_type); | |
4062 | |
4063 s->mb_intra = IS_INTRA(mb_type); | |
4064 if(HAS_CBP(mb_type)){ | |
2632 | 4065 s->dsp.clear_blocks(s->block[0]); |
1655 | 4066 cbpc = get_vlc2(&s->gb, cbpc_b_vlc.table, CBPC_B_VLC_BITS, 1); |
4067 if(s->mb_intra){ | |
4068 dquant = IS_QUANT(mb_type); | |
4069 goto intra; | |
4070 } | |
4071 | |
4072 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1); | |
4073 | |
4074 if (cbpy < 0){ | |
4075 av_log(s->avctx, AV_LOG_ERROR, "b cbpy damaged at %d %d\n", s->mb_x, s->mb_y); | |
4076 return -1; | |
4077 } | |
2967 | 4078 |
1655 | 4079 if(s->alt_inter_vlc==0 || (cbpc & 3)!=3) |
4080 cbpy ^= 0xF; | |
2967 | 4081 |
1655 | 4082 cbp = (cbpc & 3) | (cbpy << 2); |
4083 }else | |
4084 cbp=0; | |
2967 | 4085 |
1655 | 4086 assert(!s->mb_intra); |
4087 | |
4088 if(IS_QUANT(mb_type)){ | |
1656 | 4089 h263_decode_dquant(s); |
1655 | 4090 } |
4091 | |
4092 if(IS_DIRECT(mb_type)){ | |
4093 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT; | |
4094 mb_type |= ff_mpeg4_set_direct_mv(s, 0, 0); | |
4095 }else{ | |
4096 s->mv_dir = 0; | |
4097 s->mv_type= MV_TYPE_16X16; | |
4098 //FIXME UMV | |
4099 | |
4100 if(USES_LIST(mb_type, 0)){ | |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
4101 int16_t *mot_val= h263_pred_motion(s, 0, 0, &mx, &my); |
1655 | 4102 s->mv_dir = MV_DIR_FORWARD; |
4103 | |
4104 mx = h263_decode_motion(s, mx, 1); | |
4105 my = h263_decode_motion(s, my, 1); | |
2967 | 4106 |
1655 | 4107 s->mv[0][0][0] = mx; |
4108 s->mv[0][0][1] = my; | |
1701 | 4109 mot_val[0 ]= mot_val[2 ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx; |
4110 mot_val[1 ]= mot_val[3 ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my; | |
1655 | 4111 } |
2967 | 4112 |
1655 | 4113 if(USES_LIST(mb_type, 1)){ |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
4114 int16_t *mot_val= h263_pred_motion(s, 0, 1, &mx, &my); |
1655 | 4115 s->mv_dir |= MV_DIR_BACKWARD; |
2967 | 4116 |
1655 | 4117 mx = h263_decode_motion(s, mx, 1); |
4118 my = h263_decode_motion(s, my, 1); | |
1701 | 4119 |
1655 | 4120 s->mv[1][0][0] = mx; |
4121 s->mv[1][0][1] = my; | |
1701 | 4122 mot_val[0 ]= mot_val[2 ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx; |
4123 mot_val[1 ]= mot_val[3 ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my; | |
1655 | 4124 } |
4125 } | |
2967 | 4126 |
1655 | 4127 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
|
4128 } else { /* I-Frame */ |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4129 do{ |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4130 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
|
4131 if (cbpc < 0){ |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4132 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
|
4133 return -1; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4134 } |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4135 }while(cbpc == 8); |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4136 |
2632 | 4137 s->dsp.clear_blocks(s->block[0]); |
4138 | |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4139 dquant = cbpc & 4; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4140 s->mb_intra = 1; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4141 intra: |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4142 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
|
4143 if (s->h263_aic) { |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4144 s->ac_pred = get_bits1(&s->gb); |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4145 if(s->ac_pred){ |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4146 s->current_picture.mb_type[xy]= MB_TYPE_INTRA | MB_TYPE_ACPRED; |
2967 | 4147 |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4148 s->h263_aic_dir = get_bits1(&s->gb); |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4149 } |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4150 }else |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4151 s->ac_pred = 0; |
2967 | 4152 |
9103
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
4153 if(s->pb_frame && get_bits1(&s->gb)) |
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
4154 pb_mv_count = h263_get_modb(&s->gb, s->pb_frame, &cbpb); |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4155 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
|
4156 if(cbpy<0){ |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4157 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
|
4158 return -1; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4159 } |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4160 cbp = (cbpc & 3) | (cbpy << 2); |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4161 if (dquant) { |
1656 | 4162 h263_decode_dquant(s); |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4163 } |
9103
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
4164 |
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
4165 pb_mv_count += !!s->pb_frame; |
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
4166 } |
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
4167 |
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
4168 while(pb_mv_count--){ |
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
4169 h263_decode_motion(s, 0, 1); |
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
4170 h263_decode_motion(s, 0, 1); |
9093 | 4171 } |
4172 | |
4173 /* decode each block */ | |
4174 for (i = 0; i < 6; i++) { | |
4175 if (h263_decode_block(s, block[i], i, cbp&32) < 0) | |
4176 return -1; | |
4177 cbp+=cbp; | |
4178 } | |
4179 | |
9103
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
4180 if(s->pb_frame && h263_skip_b_part(s, cbpb) < 0) |
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
4181 return -1; |
9093 | 4182 if(s->obmc && !s->mb_intra){ |
4183 if(s->pict_type == FF_P_TYPE && s->mb_x+1<s->mb_width && s->mb_num_left != 1) | |
4184 preview_obmc(s); | |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4185 } |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4186 end: |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4187 |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4188 /* per-MB end of slice check */ |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4189 { |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4190 int v= show_bits(&s->gb, 16); |
2967 | 4191 |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4192 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
|
4193 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
|
4194 } |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4195 |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4196 if(v==0) |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4197 return SLICE_END; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4198 } |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4199 |
2967 | 4200 return SLICE_OK; |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4201 } |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4202 |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4203 int ff_mpeg4_decode_mb(MpegEncContext *s, |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4204 DCTELEM block[6][64]) |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4205 { |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4206 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
|
4207 int16_t *mot_val; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4208 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
|
4209 const int xy= s->mb_x + s->mb_y * s->mb_stride; |
2967 | 4210 |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4211 assert(s->h263_pred); |
2967 | 4212 |
6481 | 4213 if (s->pict_type == FF_P_TYPE || s->pict_type==FF_S_TYPE) { |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4214 do{ |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4215 if (get_bits1(&s->gb)) { |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4216 /* skip mb */ |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4217 s->mb_intra = 0; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4218 for(i=0;i<6;i++) |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4219 s->block_last_index[i] = -1; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4220 s->mv_dir = MV_DIR_FORWARD; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4221 s->mv_type = MV_TYPE_16X16; |
6481 | 4222 if(s->pict_type==FF_S_TYPE && s->vol_sprite_usage==GMC_SPRITE){ |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4223 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
|
4224 s->mcsel=1; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4225 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
|
4226 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
|
4227 |
2628
511e3afc43e1
Ministry of English Composition, reporting for duty (and the word is "skipped", not "skiped"; "skiped" would rhyme with "hyped")
melanson
parents:
2615
diff
changeset
|
4228 s->mb_skipped = 0; |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4229 }else{ |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4230 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
|
4231 s->mcsel=0; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4232 s->mv[0][0][0] = 0; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4233 s->mv[0][0][1] = 0; |
2628
511e3afc43e1
Ministry of English Composition, reporting for duty (and the word is "skipped", not "skiped"; "skiped" would rhyme with "hyped")
melanson
parents:
2615
diff
changeset
|
4234 s->mb_skipped = 1; |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4235 } |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4236 goto end; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4237 } |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4238 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
|
4239 //fprintf(stderr, "\tCBPC: %d", cbpc); |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4240 if (cbpc < 0){ |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4241 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
|
4242 return -1; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4243 } |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4244 }while(cbpc == 20); |
2967 | 4245 |
2632 | 4246 s->dsp.clear_blocks(s->block[0]); |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4247 dquant = cbpc & 8; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4248 s->mb_intra = ((cbpc & 4) != 0); |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4249 if (s->mb_intra) goto intra; |
2967 | 4250 |
6481 | 4251 if(s->pict_type==FF_S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0) |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4252 s->mcsel= get_bits1(&s->gb); |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4253 else s->mcsel= 0; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4254 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1) ^ 0x0F; |
2967 | 4255 |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4256 cbp = (cbpc & 3) | (cbpy << 2); |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4257 if (dquant) { |
1652 | 4258 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
|
4259 } |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4260 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
|
4261 s->interlaced_dct= get_bits1(&s->gb); |
2967 | 4262 |
0 | 4263 s->mv_dir = MV_DIR_FORWARD; |
4264 if ((cbpc & 16) == 0) { | |
619
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4265 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
|
4266 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
|
4267 /* 16x16 global motion prediction */ |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4268 s->mv_type = MV_TYPE_16X16; |
753 | 4269 mx= get_amv(s, 0); |
4270 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
|
4271 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
|
4272 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
|
4273 }else if((!s->progressive_sequence) && get_bits1(&s->gb)){ |
2967 | 4274 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
|
4275 /* 16x8 field motion prediction */ |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4276 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
|
4277 |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4278 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
|
4279 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
|
4280 |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
4281 h263_pred_motion(s, 0, 0, &pred_x, &pred_y); |
2967 | 4282 |
619
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4283 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
|
4284 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
|
4285 if (mx >= 0xffff) |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4286 return -1; |
2967 | 4287 |
619
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4288 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
|
4289 if (my >= 0xffff) |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4290 return -1; |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4291 |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4292 s->mv[0][i][0] = mx; |
661 | 4293 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
|
4294 } |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4295 }else{ |
2967 | 4296 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
|
4297 /* 16x16 motion prediction */ |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4298 s->mv_type = MV_TYPE_16X16; |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
4299 h263_pred_motion(s, 0, 0, &pred_x, &pred_y); |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4300 mx = h263_decode_motion(s, pred_x, s->f_code); |
2967 | 4301 |
619
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4302 if (mx >= 0xffff) |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4303 return -1; |
2967 | 4304 |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4305 my = h263_decode_motion(s, pred_y, s->f_code); |
2967 | 4306 |
619
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4307 if (my >= 0xffff) |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4308 return -1; |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4309 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
|
4310 s->mv[0][0][1] = my; |
255 | 4311 } |
0 | 4312 } else { |
2967 | 4313 s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0; |
0 | 4314 s->mv_type = MV_TYPE_8X8; |
4315 for(i=0;i<4;i++) { | |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
4316 mot_val = h263_pred_motion(s, i, 0, &pred_x, &pred_y); |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4317 mx = h263_decode_motion(s, pred_x, s->f_code); |
0 | 4318 if (mx >= 0xffff) |
4319 return -1; | |
2967 | 4320 |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4321 my = h263_decode_motion(s, pred_y, s->f_code); |
0 | 4322 if (my >= 0xffff) |
4323 return -1; | |
4324 s->mv[0][i][0] = mx; | |
4325 s->mv[0][i][1] = my; | |
4326 mot_val[0] = mx; | |
4327 mot_val[1] = my; | |
4328 } | |
4329 } | |
6481 | 4330 } else if(s->pict_type==FF_B_TYPE) { |
262 | 4331 int modb1; // first bit of modb |
4332 int modb2; // second bit of modb | |
4333 int mb_type; | |
4334 | |
4335 s->mb_intra = 0; //B-frames never contain intra blocks | |
4336 s->mcsel=0; // ... true gmc blocks | |
4337 | |
4338 if(s->mb_x==0){ | |
674 | 4339 for(i=0; i<2; i++){ |
2967 | 4340 s->last_mv[i][0][0]= |
4341 s->last_mv[i][0][1]= | |
4342 s->last_mv[i][1][0]= | |
674 | 4343 s->last_mv[i][1][1]= 0; |
4344 } | |
262 | 4345 } |
4346 | |
4347 /* if we skipped it in the future P Frame than skip it now too */ | |
2628
511e3afc43e1
Ministry of English Composition, reporting for duty (and the word is "skipped", not "skiped"; "skiped" would rhyme with "hyped")
melanson
parents:
2615
diff
changeset
|
4348 s->mb_skipped= s->next_picture.mbskip_table[s->mb_y * s->mb_stride + s->mb_x]; // Note, skiptab=0 if last was GMC |
511e3afc43e1
Ministry of English Composition, reporting for duty (and the word is "skipped", not "skiped"; "skiped" would rhyme with "hyped")
melanson
parents:
2615
diff
changeset
|
4349 |
511e3afc43e1
Ministry of English Composition, reporting for duty (and the word is "skipped", not "skiped"; "skiped" would rhyme with "hyped")
melanson
parents:
2615
diff
changeset
|
4350 if(s->mb_skipped){ |
262 | 4351 /* skip mb */ |
4352 for(i=0;i<6;i++) | |
4353 s->block_last_index[i] = -1; | |
4354 | |
4355 s->mv_dir = MV_DIR_FORWARD; | |
4356 s->mv_type = MV_TYPE_16X16; | |
4357 s->mv[0][0][0] = 0; | |
4358 s->mv[0][0][1] = 0; | |
4359 s->mv[1][0][0] = 0; | |
4360 s->mv[1][0][1] = 0; | |
2967 | 4361 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
|
4362 goto end; |
262 | 4363 } |
4364 | |
2967 | 4365 modb1= get_bits1(&s->gb); |
666 | 4366 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
|
4367 mb_type= MB_TYPE_DIRECT2 | MB_TYPE_SKIP | MB_TYPE_L0L1; //like MB_TYPE_B_DIRECT but no vectors coded |
666 | 4368 cbp=0; |
4369 }else{ | |
262 | 4370 modb2= get_bits1(&s->gb); |
544 | 4371 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
|
4372 if(mb_type<0){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
4373 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
|
4374 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
|
4375 } |
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
|
4376 mb_type= mb_type_b_map[ mb_type ]; |
666 | 4377 if(modb2) cbp= 0; |
2632 | 4378 else{ |
4379 s->dsp.clear_blocks(s->block[0]); | |
4380 cbp= get_bits(&s->gb, 6); | |
4381 } | |
666 | 4382 |
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
|
4383 if ((!IS_DIRECT(mb_type)) && cbp) { |
262 | 4384 if(get_bits1(&s->gb)){ |
1652 | 4385 ff_set_qscale(s, s->qscale + get_bits1(&s->gb)*4 - 2); |
262 | 4386 } |
4387 } | |
664 | 4388 |
4389 if(!s->progressive_sequence){ | |
4390 if(cbp) | |
4391 s->interlaced_dct= get_bits1(&s->gb); | |
4392 | |
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
|
4393 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
|
4394 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
|
4395 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
|
4396 |
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
|
4397 if(USES_LIST(mb_type, 0)){ |
667 | 4398 s->field_select[0][0]= get_bits1(&s->gb); |
4399 s->field_select[0][1]= get_bits1(&s->gb); | |
4400 } | |
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
|
4401 if(USES_LIST(mb_type, 1)){ |
667 | 4402 s->field_select[1][0]= get_bits1(&s->gb); |
4403 s->field_select[1][1]= get_bits1(&s->gb); | |
4404 } | |
4405 } | |
666 | 4406 } |
4407 | |
667 | 4408 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
|
4409 if((mb_type & (MB_TYPE_DIRECT2|MB_TYPE_INTERLACED)) == 0){ |
666 | 4410 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
|
4411 |
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
|
4412 if(USES_LIST(mb_type, 0)){ |
666 | 4413 s->mv_dir = MV_DIR_FORWARD; |
4414 | |
4415 mx = h263_decode_motion(s, s->last_mv[0][0][0], s->f_code); | |
4416 my = h263_decode_motion(s, s->last_mv[0][0][1], s->f_code); | |
4417 s->last_mv[0][1][0]= s->last_mv[0][0][0]= s->mv[0][0][0] = mx; | |
4418 s->last_mv[0][1][1]= s->last_mv[0][0][1]= s->mv[0][0][1] = my; | |
667 | 4419 } |
2967 | 4420 |
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
|
4421 if(USES_LIST(mb_type, 1)){ |
666 | 4422 s->mv_dir |= MV_DIR_BACKWARD; |
4423 | |
4424 mx = h263_decode_motion(s, s->last_mv[1][0][0], s->b_code); | |
4425 my = h263_decode_motion(s, s->last_mv[1][0][1], s->b_code); | |
4426 s->last_mv[1][1][0]= s->last_mv[1][0][0]= s->mv[1][0][0] = mx; | |
4427 s->last_mv[1][1][1]= s->last_mv[1][0][1]= s->mv[1][0][1] = my; | |
4428 } | |
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
|
4429 }else if(!IS_DIRECT(mb_type)){ |
666 | 4430 s->mv_type= MV_TYPE_FIELD; |
667 | 4431 |
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
|
4432 if(USES_LIST(mb_type, 0)){ |
666 | 4433 s->mv_dir = MV_DIR_FORWARD; |
2967 | 4434 |
666 | 4435 for(i=0; i<2; i++){ |
4436 mx = h263_decode_motion(s, s->last_mv[0][i][0] , s->f_code); | |
4437 my = h263_decode_motion(s, s->last_mv[0][i][1]/2, s->f_code); | |
4438 s->last_mv[0][i][0]= s->mv[0][i][0] = mx; | |
4439 s->last_mv[0][i][1]= (s->mv[0][i][1] = my)*2; | |
4440 } | |
667 | 4441 } |
2967 | 4442 |
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
|
4443 if(USES_LIST(mb_type, 1)){ |
666 | 4444 s->mv_dir |= MV_DIR_BACKWARD; |
4445 | |
4446 for(i=0; i<2; i++){ | |
4447 mx = h263_decode_motion(s, s->last_mv[1][i][0] , s->b_code); | |
4448 my = h263_decode_motion(s, s->last_mv[1][i][1]/2, s->b_code); | |
4449 s->last_mv[1][i][0]= s->mv[1][i][0] = mx; | |
4450 s->last_mv[1][i][1]= (s->mv[1][i][1] = my)*2; | |
664 | 4451 } |
4452 } | |
4453 } | |
4454 } | |
2967 | 4455 |
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
|
4456 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
|
4457 if(IS_SKIP(mb_type)) |
666 | 4458 mx=my=0; |
4459 else{ | |
4460 mx = h263_decode_motion(s, 0, 1); | |
4461 my = h263_decode_motion(s, 0, 1); | |
4462 } | |
2967 | 4463 |
262 | 4464 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
|
4465 mb_type |= ff_mpeg4_set_direct_mv(s, mx, my); |
664 | 4466 } |
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
|
4467 s->current_picture.mb_type[xy]= mb_type; |
262 | 4468 } else { /* I-Frame */ |
1482 | 4469 do{ |
4470 cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2); | |
4471 if (cbpc < 0){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
4472 av_log(s->avctx, AV_LOG_ERROR, "I cbpc damaged at %d %d\n", s->mb_x, s->mb_y); |
1482 | 4473 return -1; |
4474 } | |
4475 }while(cbpc == 8); | |
4476 | |
262 | 4477 dquant = cbpc & 4; |
4478 s->mb_intra = 1; | |
4479 intra: | |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4480 s->ac_pred = get_bits1(&s->gb); |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4481 if(s->ac_pred) |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4482 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
|
4483 else |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4484 s->current_picture.mb_type[xy]= MB_TYPE_INTRA; |
2967 | 4485 |
544 | 4486 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1); |
1482 | 4487 if(cbpy<0){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
4488 av_log(s->avctx, AV_LOG_ERROR, "I cbpy damaged at %d %d\n", s->mb_x, s->mb_y); |
1482 | 4489 return -1; |
4490 } | |
0 | 4491 cbp = (cbpc & 3) | (cbpy << 2); |
3282 | 4492 |
4493 s->use_intra_dc_vlc= s->qscale < s->intra_dc_threshold; | |
4494 | |
0 | 4495 if (dquant) { |
1652 | 4496 ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]); |
0 | 4497 } |
2967 | 4498 |
619
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4499 if(!s->progressive_sequence) |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4500 s->interlaced_dct= get_bits1(&s->gb); |
575 | 4501 |
2632 | 4502 s->dsp.clear_blocks(s->block[0]); |
575 | 4503 /* decode each block */ |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4504 for (i = 0; i < 6; i++) { |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4505 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
|
4506 return -1; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4507 cbp+=cbp; |
575 | 4508 } |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4509 goto end; |
0 | 4510 } |
4511 | |
4512 /* decode each block */ | |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4513 for (i = 0; i < 6; i++) { |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4514 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
|
4515 return -1; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4516 cbp+=cbp; |
0 | 4517 } |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4518 end: |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4519 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4520 /* per-MB end of slice check */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4521 if(s->codec_id==CODEC_ID_MPEG4){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4522 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
|
4523 const int delta= s->mb_x + 1 == s->mb_width ? 2 : 1; |
6481 | 4524 if(s->pict_type==FF_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
|
4525 return SLICE_OK; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4526 return SLICE_END; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4527 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4528 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4529 |
2967 | 4530 return SLICE_OK; |
0 | 4531 } |
4532 | |
262 | 4533 static int h263_decode_motion(MpegEncContext * s, int pred, int f_code) |
0 | 4534 { |
656
e47fa3e3f2d5
statistics for forw & back p-MBs instead of just one counter for both
michaelni
parents:
654
diff
changeset
|
4535 int code, val, sign, shift, l; |
544 | 4536 code = get_vlc2(&s->gb, mv_vlc.table, MV_VLC_BITS, 2); |
0 | 4537 |
4538 if (code == 0) | |
4539 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
|
4540 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
|
4541 return 0xffff; |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
702
diff
changeset
|
4542 |
21 | 4543 sign = get_bits1(&s->gb); |
262 | 4544 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
|
4545 val = code; |
625ccacd1113
decode motion & modulo optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1254
diff
changeset
|
4546 if (shift) { |
625ccacd1113
decode motion & modulo optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1254
diff
changeset
|
4547 val = (val - 1) << shift; |
0 | 4548 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
|
4549 val++; |
625ccacd1113
decode motion & modulo optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1254
diff
changeset
|
4550 } |
0 | 4551 if (sign) |
4552 val = -val; | |
4553 val += pred; | |
475 | 4554 |
0 | 4555 /* modulo decoding */ |
4556 if (!s->h263_long_vectors) { | |
2093 | 4557 l = INT_BIT - 5 - f_code; |
4558 val = (val<<l)>>l; | |
0 | 4559 } else { |
4560 /* horrible h263 long vector mode */ | |
4561 if (pred < -31 && val < -63) | |
4562 val += 64; | |
4563 if (pred > 32 && val > 63) | |
4564 val -= 64; | |
2967 | 4565 |
0 | 4566 } |
4567 return val; | |
4568 } | |
4569 | |
78 | 4570 /* Decodes RVLC of H.263+ UMV */ |
4571 static int h263p_decode_umotion(MpegEncContext * s, int pred) | |
4572 { | |
4573 int code = 0, sign; | |
2967 | 4574 |
78 | 4575 if (get_bits1(&s->gb)) /* Motion difference = 0 */ |
4576 return pred; | |
2967 | 4577 |
78 | 4578 code = 2 + get_bits1(&s->gb); |
2967 | 4579 |
78 | 4580 while (get_bits1(&s->gb)) |
4581 { | |
4582 code <<= 1; | |
4583 code += get_bits1(&s->gb); | |
4584 } | |
4585 sign = code & 1; | |
4586 code >>= 1; | |
2967 | 4587 |
78 | 4588 code = (sign) ? (pred - code) : (pred + code); |
4589 #ifdef DEBUG | |
2846
40765c51a7a9
Compilation fixes part 1 patch by (Arvind R. and Burkhard Plaum, plaum, ipf uni-stuttgart de)
michael
parents:
2814
diff
changeset
|
4590 av_log( s->avctx, AV_LOG_DEBUG,"H.263+ UMV Motion = %d\n", code); |
78 | 4591 #endif |
2967 | 4592 return code; |
78 | 4593 |
4594 } | |
4595 | |
0 | 4596 static int h263_decode_block(MpegEncContext * s, DCTELEM * block, |
4597 int n, int coded) | |
4598 { | |
4599 int code, level, i, j, last, run; | |
4600 RLTable *rl = &rl_inter; | |
1064 | 4601 const uint8_t *scan_table; |
1637 | 4602 GetBitContext gb= s->gb; |
0 | 4603 |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
702
diff
changeset
|
4604 scan_table = s->intra_scantable.permutated; |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
4605 if (s->h263_aic && s->mb_intra) { |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
4606 rl = &rl_intra_aic; |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
4607 i = 0; |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
4608 if (s->ac_pred) { |
2967 | 4609 if (s->h263_aic_dir) |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
702
diff
changeset
|
4610 scan_table = s->intra_v_scantable.permutated; /* left */ |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
4611 else |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
702
diff
changeset
|
4612 scan_table = s->intra_h_scantable.permutated; /* top */ |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
4613 } |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
4614 } else if (s->mb_intra) { |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
4615 /* DC coef */ |
1641 | 4616 if(s->codec_id == CODEC_ID_RV10){ |
8590 | 4617 #if CONFIG_RV10_DECODER |
6481 | 4618 if (s->rv10_version == 3 && s->pict_type == FF_I_TYPE) { |
0 | 4619 int component, diff; |
4620 component = (n <= 3 ? 0 : n - 4 + 1); | |
4621 level = s->last_dc[component]; | |
4622 if (s->rv10_first_dc_coded[component]) { | |
4623 diff = rv_decode_dc(s, n); | |
4624 if (diff == 0xffff) | |
4625 return -1; | |
4626 level += diff; | |
4627 level = level & 0xff; /* handle wrap round */ | |
4628 s->last_dc[component] = level; | |
4629 } else { | |
4630 s->rv10_first_dc_coded[component] = 1; | |
4631 } | |
1090 | 4632 } else { |
4633 level = get_bits(&s->gb, 8); | |
1975 | 4634 if (level == 255) |
4635 level = 128; | |
1090 | 4636 } |
2639 | 4637 #endif |
1090 | 4638 }else{ |
0 | 4639 level = get_bits(&s->gb, 8); |
1089 | 4640 if((level&0x7F) == 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, "illegal dc %d at %d %d\n", level, s->mb_x, s->mb_y); |
7831 | 4642 if(s->error_recognition >= FF_ER_COMPLIANT) |
1752 | 4643 return -1; |
1089 | 4644 } |
0 | 4645 if (level == 255) |
4646 level = 128; | |
4647 } | |
4648 block[0] = level; | |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
4649 i = 1; |
0 | 4650 } else { |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
4651 i = 0; |
0 | 4652 } |
4653 if (!coded) { | |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
4654 if (s->mb_intra && s->h263_aic) |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
4655 goto not_coded; |
0 | 4656 s->block_last_index[n] = i - 1; |
4657 return 0; | |
4658 } | |
1637 | 4659 retry: |
0 | 4660 for(;;) { |
544 | 4661 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
|
4662 if (code < 0){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
4663 av_log(s->avctx, AV_LOG_ERROR, "illegal ac vlc code at %dx%d\n", s->mb_x, s->mb_y); |
0 | 4664 return -1; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4665 } |
0 | 4666 if (code == rl->n) { |
4667 /* escape */ | |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
4668 if (s->h263_flv > 1) { |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
4669 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
|
4670 last = get_bits1(&s->gb); |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
4671 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
|
4672 if(is11){ |
1356 | 4673 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
|
4674 } else { |
1356 | 4675 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
|
4676 } |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
4677 } else { |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
4678 last = get_bits1(&s->gb); |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
4679 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
|
4680 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
|
4681 if(level == -128){ |
1641 | 4682 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
|
4683 /* XXX: should patch encoder too */ |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
4684 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
|
4685 }else{ |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
4686 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
|
4687 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
|
4688 } |
1089 | 4689 } |
0 | 4690 } |
4691 } else { | |
4692 run = rl->table_run[code]; | |
4693 level = rl->table_level[code]; | |
4694 last = code >= rl->last; | |
21 | 4695 if (get_bits1(&s->gb)) |
0 | 4696 level = -level; |
4697 } | |
4698 i += run; | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4699 if (i >= 64){ |
1637 | 4700 if(s->alt_inter_vlc && rl == &rl_inter && !s->mb_intra){ |
5129 | 4701 //Looks like a hack but no, it's the way it is supposed to work ... |
1637 | 4702 rl = &rl_intra_aic; |
4703 i = 0; | |
4704 s->gb= gb; | |
8288 | 4705 s->dsp.clear_block(block); |
1637 | 4706 goto retry; |
4707 } | |
2406 | 4708 av_log(s->avctx, AV_LOG_ERROR, "run overflow at %dx%d i:%d\n", s->mb_x, s->mb_y, s->mb_intra); |
0 | 4709 return -1; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4710 } |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
4711 j = scan_table[i]; |
0 | 4712 block[j] = level; |
4713 if (last) | |
4714 break; | |
4715 i++; | |
4716 } | |
2967 | 4717 not_coded: |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
4718 if (s->mb_intra && s->h263_aic) { |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
4719 h263_pred_acdc(s, block, n); |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
4720 i = 63; |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
4721 } |
0 | 4722 s->block_last_index[n] = i; |
4723 return 0; | |
4724 } | |
4725 | |
1034 | 4726 /** |
4727 * decodes the dc value. | |
4728 * @param n block index (0-3 are luma, 4-5 are chroma) | |
4729 * @param dir_ptr the prediction direction will be stored here | |
4730 * @return the quantized dc | |
4731 */ | |
453 | 4732 static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr) |
0 | 4733 { |
2003 | 4734 int level, code; |
0 | 4735 |
2967 | 4736 if (n < 4) |
544 | 4737 code = get_vlc2(&s->gb, dc_lum.table, DC_VLC_BITS, 1); |
2967 | 4738 else |
544 | 4739 code = get_vlc2(&s->gb, dc_chrom.table, DC_VLC_BITS, 1); |
453 | 4740 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
|
4741 av_log(s->avctx, AV_LOG_ERROR, "illegal dc vlc\n"); |
0 | 4742 return -1; |
453 | 4743 } |
0 | 4744 if (code == 0) { |
4745 level = 0; | |
4746 } 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
|
4747 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
|
4748 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
|
4749 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
|
4750 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
|
4751 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
|
4752 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
|
4753 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
|
4754 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
|
4755 } |
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
|
4756 }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
|
4757 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
|
4758 } |
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
|
4759 |
453 | 4760 if (code > 8){ |
4761 if(get_bits1(&s->gb)==0){ /* marker */ | |
7831 | 4762 if(s->error_recognition>=2){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
4763 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
|
4764 return -1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4765 } |
453 | 4766 } |
4767 } | |
0 | 4768 } |
2003 | 4769 |
4770 return ff_mpeg4_pred_dc(s, n, level, dir_ptr, 0); | |
0 | 4771 } |
4772 | |
453 | 4773 /** |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4774 * decodes a block. |
6524 | 4775 * @return <0 if an error occurred |
453 | 4776 */ |
4777 static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block, | |
1132 | 4778 int n, int coded, int intra, int rvlc) |
0 | 4779 { |
549 | 4780 int level, i, last, run; |
6211
ed359f380aa7
Revert r11689 and r11690 (uninitalized warning fix) as its theoretically
michael
parents:
6209
diff
changeset
|
4781 int dc_pred_dir; |
575 | 4782 RLTable * rl; |
4783 RL_VLC_ELEM * rl_vlc; | |
1064 | 4784 const uint8_t * scan_table; |
549 | 4785 int qmul, qadd; |
0 | 4786 |
1132 | 4787 //Note intra & rvlc should be optimized away if this is inlined |
2967 | 4788 |
575 | 4789 if(intra) { |
3282 | 4790 if(s->use_intra_dc_vlc){ |
2979 | 4791 /* DC coef */ |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4792 if(s->partitioned_frame){ |
453 | 4793 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
|
4794 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
|
4795 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
|
4796 dc_pred_dir= (s->pred_dir_table[s->mb_x + s->mb_y*s->mb_stride]<<n)&32; |
453 | 4797 }else{ |
4798 level = mpeg4_decode_dc(s, n, &dc_pred_dir); | |
4799 if (level < 0) | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4800 return -1; |
453 | 4801 } |
0 | 4802 block[0] = level; |
549 | 4803 i = 0; |
1520 | 4804 }else{ |
4805 i = -1; | |
3182 | 4806 ff_mpeg4_pred_dc(s, n, 0, &dc_pred_dir, 0); |
2967 | 4807 } |
6201 | 4808 if (!coded) |
4809 goto not_coded; | |
4810 | |
4811 if(rvlc){ | |
4812 rl = &rvlc_rl_intra; | |
4813 rl_vlc = rvlc_rl_intra.rl_vlc[0]; | |
4814 }else{ | |
4815 rl = &rl_intra; | |
4816 rl_vlc = rl_intra.rl_vlc[0]; | |
4817 } | |
4818 if (s->ac_pred) { | |
4819 if (dc_pred_dir == 0) | |
4820 scan_table = s->intra_v_scantable.permutated; /* left */ | |
4821 else | |
4822 scan_table = s->intra_h_scantable.permutated; /* top */ | |
4823 } else { | |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
702
diff
changeset
|
4824 scan_table = s->intra_scantable.permutated; |
6201 | 4825 } |
4826 qmul=1; | |
4827 qadd=0; | |
0 | 4828 } else { |
549 | 4829 i = -1; |
0 | 4830 if (!coded) { |
549 | 4831 s->block_last_index[n] = i; |
0 | 4832 return 0; |
4833 } | |
1132 | 4834 if(rvlc) rl = &rvlc_rl_inter; |
4835 else rl = &rl_inter; | |
2967 | 4836 |
718 | 4837 scan_table = s->intra_scantable.permutated; |
661 | 4838 |
591 | 4839 if(s->mpeg_quant){ |
4840 qmul=1; | |
4841 qadd=0; | |
2967 | 4842 if(rvlc){ |
4843 rl_vlc = rvlc_rl_inter.rl_vlc[0]; | |
1132 | 4844 }else{ |
2967 | 4845 rl_vlc = rl_inter.rl_vlc[0]; |
1132 | 4846 } |
591 | 4847 }else{ |
4848 qmul = s->qscale << 1; | |
4849 qadd = (s->qscale - 1) | 1; | |
2967 | 4850 if(rvlc){ |
4851 rl_vlc = rvlc_rl_inter.rl_vlc[s->qscale]; | |
1132 | 4852 }else{ |
2967 | 4853 rl_vlc = rl_inter.rl_vlc[s->qscale]; |
1132 | 4854 } |
591 | 4855 } |
0 | 4856 } |
549 | 4857 { |
4858 OPEN_READER(re, &s->gb); | |
0 | 4859 for(;;) { |
549 | 4860 UPDATE_CACHE(re, &s->gb); |
2615
0d88e3f89379
avoid UPDATE_CACHE() in GET_RL_VLC() if not needed
michael
parents:
2572
diff
changeset
|
4861 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 0); |
549 | 4862 if (level==0) { |
2967 | 4863 /* escape */ |
1132 | 4864 if(rvlc){ |
4865 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
|
4866 av_log(s->avctx, AV_LOG_ERROR, "1. marker bit missing in rvlc esc\n"); |
1132 | 4867 return -1; |
4868 }; SKIP_CACHE(re, &s->gb, 1); | |
2967 | 4869 |
1132 | 4870 last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1); |
4871 run= SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6); | |
4872 SKIP_COUNTER(re, &s->gb, 1+1+6); | |
4873 UPDATE_CACHE(re, &s->gb); | |
2967 | 4874 |
1132 | 4875 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
|
4876 av_log(s->avctx, AV_LOG_ERROR, "2. marker bit missing in rvlc esc\n"); |
1132 | 4877 return -1; |
4878 }; SKIP_CACHE(re, &s->gb, 1); | |
2967 | 4879 |
1132 | 4880 level= SHOW_UBITS(re, &s->gb, 11); SKIP_CACHE(re, &s->gb, 11); |
2967 | 4881 |
1132 | 4882 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
|
4883 av_log(s->avctx, AV_LOG_ERROR, "reverse esc missing\n"); |
1132 | 4884 return -1; |
4885 }; SKIP_CACHE(re, &s->gb, 5); | |
4886 | |
4887 level= level * qmul + qadd; | |
4888 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); LAST_SKIP_CACHE(re, &s->gb, 1); | |
4889 SKIP_COUNTER(re, &s->gb, 1+11+5+1); | |
4890 | |
4891 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
|
4892 if(last) i+=192; |
1132 | 4893 }else{ |
549 | 4894 int cache; |
4895 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
|
4896 |
2967 | 4897 if(IS_3IV1) |
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
|
4898 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
|
4899 |
549 | 4900 if (cache&0x80000000) { |
4901 if (cache&0x40000000) { | |
0 | 4902 /* third escape */ |
549 | 4903 SKIP_CACHE(re, &s->gb, 2); |
4904 last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1); | |
4905 run= SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6); | |
4906 SKIP_COUNTER(re, &s->gb, 2+1+6); | |
4907 UPDATE_CACHE(re, &s->gb); | |
4908 | |
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
|
4909 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
|
4910 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
|
4911 }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
|
4912 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
|
4913 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
|
4914 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
|
4915 }; 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
|
4916 |
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
|
4917 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
|
4918 |
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
|
4919 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
|
4920 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
|
4921 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
|
4922 }; 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
|
4923 |
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
|
4924 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
|
4925 } |
2967 | 4926 |
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
|
4927 #if 0 |
7831 | 4928 if(s->error_recognition >= FF_ER_COMPLIANT){ |
4001 | 4929 const int abs_level= FFABS(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
|
4930 if(abs_level<=MAX_LEVEL && run<=MAX_RUN){ |
498 | 4931 const int run1= run - rl->max_run[last][abs_level] - 1; |
453 | 4932 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
|
4933 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
|
4934 return -1; |
453 | 4935 } |
7831 | 4936 if(s->error_recognition > FF_ER_COMPLIANT){ |
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
|
4937 if(abs_level <= rl->max_level[last][run]*2){ |
2846
40765c51a7a9
Compilation fixes part 1 patch by (Arvind R. and Burkhard Plaum, plaum, ipf uni-stuttgart de)
michael
parents:
2814
diff
changeset
|
4938 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 1 encoding possible\n"); |
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
|
4939 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
|
4940 } |
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
|
4941 if(run1 >= 0 && abs_level <= rl->max_level[last][run1]){ |
2846
40765c51a7a9
Compilation fixes part 1 patch by (Arvind R. and Burkhard Plaum, plaum, ipf uni-stuttgart de)
michael
parents:
2814
diff
changeset
|
4942 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 2 encoding possible\n"); |
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
|
4943 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
|
4944 } |
453 | 4945 } |
4946 } | |
4947 } | |
4948 #endif | |
2979 | 4949 if (level>0) level= level * qmul + qadd; |
549 | 4950 else level= level * qmul - qadd; |
4951 | |
2080 | 4952 if((unsigned)(level + 2048) > 4095){ |
7831 | 4953 if(s->error_recognition > FF_ER_COMPLIANT){ |
2080 | 4954 if(level > 2560 || level<-2560){ |
4955 av_log(s->avctx, AV_LOG_ERROR, "|level| overflow in 3. esc, qp=%d\n", s->qscale); | |
4956 return -1; | |
4957 } | |
4958 } | |
4959 level= level<0 ? -2048 : 2047; | |
4960 } | |
4961 | |
549 | 4962 i+= run + 1; |
4963 if(last) i+=192; | |
0 | 4964 } else { |
4965 /* second escape */ | |
549 | 4966 #if MIN_CACHE_BITS < 20 |
4967 LAST_SKIP_BITS(re, &s->gb, 2); | |
4968 UPDATE_CACHE(re, &s->gb); | |
4969 #else | |
4970 SKIP_BITS(re, &s->gb, 2); | |
4971 #endif | |
2615
0d88e3f89379
avoid UPDATE_CACHE() in GET_RL_VLC() if not needed
michael
parents:
2572
diff
changeset
|
4972 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1); |
549 | 4973 i+= run + rl->max_run[run>>7][level/qmul] +1; //FIXME opt indexing |
4974 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); | |
4975 LAST_SKIP_BITS(re, &s->gb, 1); | |
0 | 4976 } |
4977 } else { | |
4978 /* first escape */ | |
549 | 4979 #if MIN_CACHE_BITS < 19 |
4980 LAST_SKIP_BITS(re, &s->gb, 1); | |
4981 UPDATE_CACHE(re, &s->gb); | |
4982 #else | |
4983 SKIP_BITS(re, &s->gb, 1); | |
4984 #endif | |
2615
0d88e3f89379
avoid UPDATE_CACHE() in GET_RL_VLC() if not needed
michael
parents:
2572
diff
changeset
|
4985 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1); |
549 | 4986 i+= run; |
4987 level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//FIXME opt indexing | |
4988 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); | |
4989 LAST_SKIP_BITS(re, &s->gb, 1); | |
0 | 4990 } |
1132 | 4991 } |
0 | 4992 } else { |
549 | 4993 i+= run; |
4994 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); | |
4995 LAST_SKIP_BITS(re, &s->gb, 1); | |
0 | 4996 } |
549 | 4997 if (i > 62){ |
4998 i-= 192; | |
4999 if(i&(~63)){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5000 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
|
5001 return -1; |
549 | 5002 } |
5003 | |
5004 block[scan_table[i]] = level; | |
0 | 5005 break; |
549 | 5006 } |
5007 | |
5008 block[scan_table[i]] = level; | |
0 | 5009 } |
549 | 5010 CLOSE_READER(re, &s->gb); |
5011 } | |
0 | 5012 not_coded: |
1520 | 5013 if (intra) { |
3282 | 5014 if(!s->use_intra_dc_vlc){ |
2003 | 5015 block[0] = ff_mpeg4_pred_dc(s, n, block[0], &dc_pred_dir, 0); |
2967 | 5016 |
3181 | 5017 i -= i>>31; //if(i == -1) i=0; |
1520 | 5018 } |
5019 | |
0 | 5020 mpeg4_pred_ac(s, block, n, dc_pred_dir); |
5021 if (s->ac_pred) { | |
549 | 5022 i = 63; /* XXX: not optimal */ |
0 | 5023 } |
5024 } | |
549 | 5025 s->block_last_index[n] = i; |
0 | 5026 return 0; |
5027 } | |
5028 | |
5029 /* most is hardcoded. should extend to handle all h263 streams */ | |
5030 int h263_decode_picture_header(MpegEncContext *s) | |
5031 { | |
1278
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
5032 int format, width, height, i; |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
5033 uint32_t startcode; |
2967 | 5034 |
1278
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
5035 align_get_bits(&s->gb); |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
5036 |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
5037 startcode= get_bits(&s->gb, 22-8); |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
5038 |
1393 | 5039 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
|
5040 startcode = ((startcode << 8) | get_bits(&s->gb, 8)) & 0x003FFFFF; |
2967 | 5041 |
1278
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
5042 if(startcode == 0x20) |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
5043 break; |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
5044 } |
2967 | 5045 |
1278
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
5046 if (startcode != 0x20) { |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5047 av_log(s->avctx, AV_LOG_ERROR, "Bad picture start code\n"); |
0 | 5048 return -1; |
355 | 5049 } |
5050 /* temporal reference */ | |
1865 | 5051 i = get_bits(&s->gb, 8); /* picture timestamp */ |
5052 if( (s->picture_number&~0xFF)+i < s->picture_number) | |
5053 i+= 256; | |
2886 | 5054 s->current_picture_ptr->pts= |
1865 | 5055 s->picture_number= (s->picture_number&~0xFF) + i; |
355 | 5056 |
2967 | 5057 /* PTYPE starts here */ |
355 | 5058 if (get_bits1(&s->gb) != 1) { |
5059 /* marker */ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5060 av_log(s->avctx, AV_LOG_ERROR, "Bad marker\n"); |
355 | 5061 return -1; |
5062 } | |
5063 if (get_bits1(&s->gb) != 0) { | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5064 av_log(s->avctx, AV_LOG_ERROR, "Bad H263 id\n"); |
2979 | 5065 return -1; /* h263 id */ |
5066 } | |
5067 skip_bits1(&s->gb); /* split screen off */ | |
5068 skip_bits1(&s->gb); /* camera off */ | |
5069 skip_bits1(&s->gb); /* freeze picture release off */ | |
0 | 5070 |
5071 format = get_bits(&s->gb, 3); | |
355 | 5072 /* |
5073 0 forbidden | |
5074 1 sub-QCIF | |
5075 10 QCIF | |
2979 | 5076 7 extended PTYPE (PLUSPTYPE) |
355 | 5077 */ |
0 | 5078 |
161 | 5079 if (format != 7 && format != 6) { |
0 | 5080 s->h263_plus = 0; |
5081 /* H.263v1 */ | |
5082 width = h263_format[format][0]; | |
5083 height = h263_format[format][1]; | |
5084 if (!width) | |
5085 return -1; | |
2967 | 5086 |
6481 | 5087 s->pict_type = FF_I_TYPE + get_bits1(&s->gb); |
0 | 5088 |
2967 | 5089 s->h263_long_vectors = get_bits1(&s->gb); |
0 | 5090 |
355 | 5091 if (get_bits1(&s->gb) != 0) { |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5092 av_log(s->avctx, AV_LOG_ERROR, "H263 SAC not supported\n"); |
2979 | 5093 return -1; /* SAC: off */ |
355 | 5094 } |
1633 | 5095 s->obmc= get_bits1(&s->gb); /* Advanced prediction mode */ |
5096 s->unrestricted_mv = s->h263_long_vectors || s->obmc; | |
2967 | 5097 |
9104 | 5098 s->pb_frame = get_bits1(&s->gb); |
1644 | 5099 s->chroma_qscale= s->qscale = get_bits(&s->gb, 5); |
2979 | 5100 skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */ |
1393 | 5101 |
5102 s->width = width; | |
5103 s->height = height; | |
1865 | 5104 s->avctx->sample_aspect_ratio= (AVRational){12,11}; |
2637 | 5105 s->avctx->time_base= (AVRational){1001, 30000}; |
0 | 5106 } else { |
161 | 5107 int ufep; |
2967 | 5108 |
0 | 5109 /* H.263v2 */ |
161 | 5110 s->h263_plus = 1; |
5111 ufep = get_bits(&s->gb, 3); /* Update Full Extended PTYPE */ | |
355 | 5112 |
2967 | 5113 /* ufep other than 0 and 1 are reserved */ |
161 | 5114 if (ufep == 1) { |
2967 | 5115 /* OPPTYPE */ |
161 | 5116 format = get_bits(&s->gb, 3); |
4652 | 5117 dprintf(s->avctx, "ufep=1, format: %d\n", format); |
1872 | 5118 s->custom_pcf= get_bits1(&s->gb); |
5513 | 5119 s->umvplus = get_bits1(&s->gb); /* Unrestricted Motion Vector */ |
1644 | 5120 if (get_bits1(&s->gb) != 0) { |
5121 av_log(s->avctx, AV_LOG_ERROR, "Syntax-based Arithmetic Coding (SAC) not supported\n"); | |
5122 } | |
1633 | 5123 s->obmc= get_bits1(&s->gb); /* Advanced prediction mode */ |
5124 s->h263_aic = get_bits1(&s->gb); /* Advanced Intra Coding (AIC) */ | |
1644 | 5125 s->loop_filter= get_bits1(&s->gb); |
5126 s->unrestricted_mv = s->umvplus || s->obmc || s->loop_filter; | |
2967 | 5127 |
1661 | 5128 s->h263_slice_structured= get_bits1(&s->gb); |
1278
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
5129 if (get_bits1(&s->gb) != 0) { |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5130 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
|
5131 } |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
5132 if (get_bits1(&s->gb) != 0) { |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5133 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
|
5134 } |
1637 | 5135 s->alt_inter_vlc= get_bits1(&s->gb); |
1639 | 5136 s->modified_quant= get_bits1(&s->gb); |
1644 | 5137 if(s->modified_quant) |
5138 s->chroma_qscale_table= ff_h263_chroma_qscale_table; | |
2967 | 5139 |
1278
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
5140 skip_bits(&s->gb, 1); /* Prevent start code emulation */ |
355 | 5141 |
161 | 5142 skip_bits(&s->gb, 3); /* Reserved */ |
355 | 5143 } else if (ufep != 0) { |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5144 av_log(s->avctx, AV_LOG_ERROR, "Bad UFEP type (%d)\n", ufep); |
0 | 5145 return -1; |
355 | 5146 } |
2967 | 5147 |
78 | 5148 /* MPPTYPE */ |
1655 | 5149 s->pict_type = get_bits(&s->gb, 3); |
5150 switch(s->pict_type){ | |
6481 | 5151 case 0: s->pict_type= FF_I_TYPE;break; |
5152 case 1: s->pict_type= FF_P_TYPE;break; | |
9104 | 5153 case 2: s->pict_type= FF_P_TYPE;s->pb_frame = 3;break; |
6481 | 5154 case 3: s->pict_type= FF_B_TYPE;break; |
5155 case 7: s->pict_type= FF_I_TYPE;break; //ZYGO | |
1655 | 5156 default: |
0 | 5157 return -1; |
1655 | 5158 } |
250
3449316664b5
- Bug fix on RTYPE (rounding type) not being honoured by H.263+ decoder.
pulento
parents:
249
diff
changeset
|
5159 skip_bits(&s->gb, 2); |
3449316664b5
- Bug fix on RTYPE (rounding type) not being honoured by H.263+ decoder.
pulento
parents:
249
diff
changeset
|
5160 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
|
5161 skip_bits(&s->gb, 4); |
2967 | 5162 |
78 | 5163 /* Get the picture dimensions */ |
161 | 5164 if (ufep) { |
5165 if (format == 6) { | |
5166 /* Custom Picture Format (CPFMT) */ | |
355 | 5167 s->aspect_ratio_info = get_bits(&s->gb, 4); |
4652 | 5168 dprintf(s->avctx, "aspect: %d\n", s->aspect_ratio_info); |
355 | 5169 /* aspect ratios: |
5170 0 - forbidden | |
5171 1 - 1:1 | |
5172 2 - 12:11 (CIF 4:3) | |
5173 3 - 10:11 (525-type 4:3) | |
5174 4 - 16:11 (CIF 16:9) | |
5175 5 - 40:33 (525-type 16:9) | |
5176 6-14 - reserved | |
5177 */ | |
161 | 5178 width = (get_bits(&s->gb, 9) + 1) * 4; |
5179 skip_bits1(&s->gb); | |
5180 height = get_bits(&s->gb, 9) * 4; | |
4652 | 5181 dprintf(s->avctx, "\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
|
5182 if (s->aspect_ratio_info == FF_ASPECT_EXTENDED) { |
355 | 5183 /* aspected dimensions */ |
1548 | 5184 s->avctx->sample_aspect_ratio.num= get_bits(&s->gb, 8); |
5185 s->avctx->sample_aspect_ratio.den= get_bits(&s->gb, 8); | |
887 | 5186 }else{ |
1548 | 5187 s->avctx->sample_aspect_ratio= pixel_aspect[s->aspect_ratio_info]; |
355 | 5188 } |
5189 } else { | |
161 | 5190 width = h263_format[format][0]; |
5191 height = h263_format[format][1]; | |
1865 | 5192 s->avctx->sample_aspect_ratio= (AVRational){12,11}; |
161 | 5193 } |
5194 if ((width == 0) || (height == 0)) | |
5195 return -1; | |
5196 s->width = width; | |
5197 s->height = height; | |
1872 | 5198 |
5199 if(s->custom_pcf){ | |
5200 int gcd; | |
2637 | 5201 s->avctx->time_base.den= 1800000; |
5202 s->avctx->time_base.num= 1000 + get_bits1(&s->gb); | |
5203 s->avctx->time_base.num*= get_bits(&s->gb, 7); | |
5204 if(s->avctx->time_base.num == 0){ | |
1872 | 5205 av_log(s, AV_LOG_ERROR, "zero framerate\n"); |
5206 return -1; | |
5207 } | |
8611 | 5208 gcd= av_gcd(s->avctx->time_base.den, s->avctx->time_base.num); |
2637 | 5209 s->avctx->time_base.den /= gcd; |
5210 s->avctx->time_base.num /= gcd; | |
5211 // av_log(s->avctx, AV_LOG_DEBUG, "%d/%d\n", s->avctx->time_base.den, s->avctx->time_base.num); | |
1872 | 5212 }else{ |
2637 | 5213 s->avctx->time_base= (AVRational){1001, 30000}; |
1872 | 5214 } |
5215 } | |
2967 | 5216 |
1872 | 5217 if(s->custom_pcf){ |
5218 skip_bits(&s->gb, 2); //extended Temporal reference | |
5219 } | |
5220 | |
5221 if (ufep) { | |
1089 | 5222 if (s->umvplus) { |
5223 if(get_bits1(&s->gb)==0) /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */ | |
2967 | 5224 skip_bits1(&s->gb); |
161 | 5225 } |
1661 | 5226 if(s->h263_slice_structured){ |
5227 if (get_bits1(&s->gb) != 0) { | |
5228 av_log(s->avctx, AV_LOG_ERROR, "rectangular slices not supported\n"); | |
5229 } | |
5230 if (get_bits1(&s->gb) != 0) { | |
5231 av_log(s->avctx, AV_LOG_ERROR, "unordered slices not supported\n"); | |
5232 } | |
5233 } | |
78 | 5234 } |
2967 | 5235 |
0 | 5236 s->qscale = get_bits(&s->gb, 5); |
5237 } | |
1670 | 5238 |
1896
ef87d53ca87a
h.263 ssm + aic fix by (Maarten Daniels <maarten dot daniels at student dot luc dot ac dot be>)
michael
parents:
1893
diff
changeset
|
5239 s->mb_width = (s->width + 15) / 16; |
ef87d53ca87a
h.263 ssm + aic fix by (Maarten Daniels <maarten dot daniels at student dot luc dot ac dot be>)
michael
parents:
1893
diff
changeset
|
5240 s->mb_height = (s->height + 15) / 16; |
ef87d53ca87a
h.263 ssm + aic fix by (Maarten Daniels <maarten dot daniels at student dot luc dot ac dot be>)
michael
parents:
1893
diff
changeset
|
5241 s->mb_num = s->mb_width * s->mb_height; |
ef87d53ca87a
h.263 ssm + aic fix by (Maarten Daniels <maarten dot daniels at student dot luc dot ac dot be>)
michael
parents:
1893
diff
changeset
|
5242 |
9104 | 5243 if (s->pb_frame) { |
5244 skip_bits(&s->gb, 3); /* Temporal reference for B-pictures */ | |
5245 if (s->custom_pcf) | |
5246 skip_bits(&s->gb, 2); //extended Temporal reference | |
5247 skip_bits(&s->gb, 2); /* Quantization information for B-pictures */ | |
5248 } | |
5249 | |
0 | 5250 /* PEI */ |
21 | 5251 while (get_bits1(&s->gb) != 0) { |
5252 skip_bits(&s->gb, 8); | |
0 | 5253 } |
1896
ef87d53ca87a
h.263 ssm + aic fix by (Maarten Daniels <maarten dot daniels at student dot luc dot ac dot be>)
michael
parents:
1893
diff
changeset
|
5254 |
1670 | 5255 if(s->h263_slice_structured){ |
5256 if (get_bits1(&s->gb) != 1) { | |
5257 av_log(s->avctx, AV_LOG_ERROR, "SEPB1 marker missing\n"); | |
5258 return -1; | |
5259 } | |
5260 | |
5261 ff_h263_decode_mba(s); | |
5262 | |
5263 if (get_bits1(&s->gb) != 1) { | |
5264 av_log(s->avctx, AV_LOG_ERROR, "SEPB2 marker missing\n"); | |
5265 return -1; | |
5266 } | |
5267 } | |
0 | 5268 s->f_code = 1; |
2967 | 5269 |
498 | 5270 if(s->h263_aic){ |
2967 | 5271 s->y_dc_scale_table= |
1639 | 5272 s->c_dc_scale_table= ff_aic_dc_scale_table; |
498 | 5273 }else{ |
5274 s->y_dc_scale_table= | |
5275 s->c_dc_scale_table= ff_mpeg1_dc_scale_table; | |
5276 } | |
5277 | |
1278
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
5278 if(s->avctx->debug&FF_DEBUG_PICT_INFO){ |
5403 | 5279 show_pict_info(s); |
1278
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
5280 } |
1584
3615999a7284
dumping funny numbers from first zygo i frame header
michael
parents:
1583
diff
changeset
|
5281 #if 1 |
8612 | 5282 if (s->pict_type == FF_I_TYPE && s->codec_tag == AV_RL32("ZYGO")){ |
1584
3615999a7284
dumping funny numbers from first zygo i frame header
michael
parents:
1583
diff
changeset
|
5283 int i,j; |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5284 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
|
5285 av_log(s->avctx, AV_LOG_DEBUG, "\n"); |
1584
3615999a7284
dumping funny numbers from first zygo i frame header
michael
parents:
1583
diff
changeset
|
5286 for(i=0; i<13; i++){ |
3615999a7284
dumping funny numbers from first zygo i frame header
michael
parents:
1583
diff
changeset
|
5287 for(j=0; j<3; j++){ |
3615999a7284
dumping funny numbers from first zygo i frame header
michael
parents:
1583
diff
changeset
|
5288 int v= get_bits(&s->gb, 8); |
3615999a7284
dumping funny numbers from first zygo i frame header
michael
parents:
1583
diff
changeset
|
5289 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
|
5290 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
|
5291 } |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5292 av_log(s->avctx, AV_LOG_DEBUG, "\n"); |
1584
3615999a7284
dumping funny numbers from first zygo i frame header
michael
parents:
1583
diff
changeset
|
5293 } |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5294 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
|
5295 } |
3615999a7284
dumping funny numbers from first zygo i frame header
michael
parents:
1583
diff
changeset
|
5296 #endif |
3615999a7284
dumping funny numbers from first zygo i frame header
michael
parents:
1583
diff
changeset
|
5297 |
0 | 5298 return 0; |
5299 } | |
5300 | |
1914 | 5301 static void mpeg4_decode_sprite_trajectory(MpegEncContext * s, GetBitContext *gb) |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5302 { |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5303 int i; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5304 int a= 2<<s->sprite_warping_accuracy; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5305 int rho= 3-s->sprite_warping_accuracy; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5306 int r=16/a; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5307 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
|
5308 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
|
5309 int sprite_ref[4][2]; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5310 int virtual_ref[2][2]; |
753 | 5311 int w2, h2, w3, h3; |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5312 int alpha=0, beta=0; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5313 int w= s->width; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5314 int h= s->height; |
753 | 5315 int min_ab; |
5316 | |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5317 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
|
5318 int length; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5319 int x=0, y=0; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5320 |
3024
67d3bb5a4ce1
get_vlc -> get_vlc2 transition and get_vlc() removed from bitstream.h
banan
parents:
2985
diff
changeset
|
5321 length= get_vlc2(gb, sprite_trajectory.table, SPRITE_TRAJ_VLC_BITS, 3); |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5322 if(length){ |
1914 | 5323 x= get_xbits(gb, length); |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5324 } |
1914 | 5325 if(!(s->divx_version==500 && s->divx_build==413)) skip_bits1(gb); /* marker bit */ |
2967 | 5326 |
3024
67d3bb5a4ce1
get_vlc -> get_vlc2 transition and get_vlc() removed from bitstream.h
banan
parents:
2985
diff
changeset
|
5327 length= get_vlc2(gb, sprite_trajectory.table, SPRITE_TRAJ_VLC_BITS, 3); |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5328 if(length){ |
1914 | 5329 y=get_xbits(gb, length); |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5330 } |
1914 | 5331 skip_bits1(gb); /* marker bit */ |
255 | 5332 //printf("%d %d %d %d\n", x, y, i, s->sprite_warping_accuracy); |
9290
0bd35457454e
Record MPEG-4 sprite trajectory points [up to num_sprite_warping_points][isY].
gb
parents:
9259
diff
changeset
|
5333 s->sprite_traj[i][0]= d[i][0]= x; |
0bd35457454e
Record MPEG-4 sprite trajectory points [up to num_sprite_warping_points][isY].
gb
parents:
9259
diff
changeset
|
5334 s->sprite_traj[i][1]= d[i][1]= y; |
0bd35457454e
Record MPEG-4 sprite trajectory points [up to num_sprite_warping_points][isY].
gb
parents:
9259
diff
changeset
|
5335 } |
0bd35457454e
Record MPEG-4 sprite trajectory points [up to num_sprite_warping_points][isY].
gb
parents:
9259
diff
changeset
|
5336 for(; i<4; i++) |
0bd35457454e
Record MPEG-4 sprite trajectory points [up to num_sprite_warping_points][isY].
gb
parents:
9259
diff
changeset
|
5337 s->sprite_traj[i][0]= s->sprite_traj[i][1]= 0; |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5338 |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5339 while((1<<alpha)<w) alpha++; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5340 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
|
5341 w2= 1<<alpha; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5342 h2= 1<<beta; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5343 |
2646
c735e3e60ca7
Even More spelling errors. patch by (Kevin Baragona <kevinmb500 gawab com)
michael
parents:
2639
diff
changeset
|
5344 // Note, the 4th point isn't used for GMC |
262 | 5345 if(s->divx_version==500 && s->divx_build==413){ |
5346 sprite_ref[0][0]= a*vop_ref[0][0] + d[0][0]; | |
5347 sprite_ref[0][1]= a*vop_ref[0][1] + d[0][1]; | |
5348 sprite_ref[1][0]= a*vop_ref[1][0] + d[0][0] + d[1][0]; | |
5349 sprite_ref[1][1]= a*vop_ref[1][1] + d[0][1] + d[1][1]; | |
5350 sprite_ref[2][0]= a*vop_ref[2][0] + d[0][0] + d[2][0]; | |
5351 sprite_ref[2][1]= a*vop_ref[2][1] + d[0][1] + d[2][1]; | |
5352 } else { | |
5353 sprite_ref[0][0]= (a>>1)*(2*vop_ref[0][0] + d[0][0]); | |
5354 sprite_ref[0][1]= (a>>1)*(2*vop_ref[0][1] + d[0][1]); | |
5355 sprite_ref[1][0]= (a>>1)*(2*vop_ref[1][0] + d[0][0] + d[1][0]); | |
5356 sprite_ref[1][1]= (a>>1)*(2*vop_ref[1][1] + d[0][1] + d[1][1]); | |
5357 sprite_ref[2][0]= (a>>1)*(2*vop_ref[2][0] + d[0][0] + d[2][0]); | |
5358 sprite_ref[2][1]= (a>>1)*(2*vop_ref[2][1] + d[0][1] + d[2][1]); | |
5359 } | |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5360 /* 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
|
5361 sprite_ref[3][1]= (a>>1)*(2*vop_ref[3][1] + d[0][1] + d[1][1] + d[2][1] + d[3][1]); */ |
2967 | 5362 |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5363 // 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
|
5364 // 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
|
5365 // 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
|
5366 // so the distance between points is converted from w&h based to w2&h2 based which are of the 2^x form |
2967 | 5367 virtual_ref[0][0]= 16*(vop_ref[0][0] + w2) |
359 | 5368 + 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); |
2967 | 5369 virtual_ref[0][1]= 16*vop_ref[0][1] |
359 | 5370 + 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); |
2967 | 5371 virtual_ref[1][0]= 16*vop_ref[0][0] |
359 | 5372 + 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); |
2967 | 5373 virtual_ref[1][1]= 16*(vop_ref[0][1] + h2) |
359 | 5374 + 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); |
2967 | 5375 |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5376 switch(s->num_sprite_warping_points) |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5377 { |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5378 case 0: |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5379 s->sprite_offset[0][0]= 0; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5380 s->sprite_offset[0][1]= 0; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5381 s->sprite_offset[1][0]= 0; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5382 s->sprite_offset[1][1]= 0; |
753 | 5383 s->sprite_delta[0][0]= a; |
5384 s->sprite_delta[0][1]= 0; | |
5385 s->sprite_delta[1][0]= 0; | |
5386 s->sprite_delta[1][1]= a; | |
5387 s->sprite_shift[0]= 0; | |
5388 s->sprite_shift[1]= 0; | |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5389 break; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5390 case 1: //GMC only |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5391 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
|
5392 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
|
5393 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
|
5394 s->sprite_offset[1][1]= ((sprite_ref[0][1]>>1)|(sprite_ref[0][1]&1)) - a*(vop_ref[0][1]/2); |
753 | 5395 s->sprite_delta[0][0]= a; |
5396 s->sprite_delta[0][1]= 0; | |
5397 s->sprite_delta[1][0]= 0; | |
5398 s->sprite_delta[1][1]= a; | |
5399 s->sprite_shift[0]= 0; | |
5400 s->sprite_shift[1]= 0; | |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5401 break; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5402 case 2: |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5403 s->sprite_offset[0][0]= (sprite_ref[0][0]<<(alpha+rho)) |
753 | 5404 + (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][0]) |
5405 + ( r*sprite_ref[0][1] - virtual_ref[0][1])*(-vop_ref[0][1]) | |
5406 + (1<<(alpha+rho-1)); | |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5407 s->sprite_offset[0][1]= (sprite_ref[0][1]<<(alpha+rho)) |
753 | 5408 + (-r*sprite_ref[0][1] + virtual_ref[0][1])*(-vop_ref[0][0]) |
5409 + (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][1]) | |
5410 + (1<<(alpha+rho-1)); | |
5411 s->sprite_offset[1][0]= ( (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][0] + 1) | |
5412 +( r*sprite_ref[0][1] - virtual_ref[0][1])*(-2*vop_ref[0][1] + 1) | |
2967 | 5413 +2*w2*r*sprite_ref[0][0] |
5414 - 16*w2 | |
753 | 5415 + (1<<(alpha+rho+1))); |
2967 | 5416 s->sprite_offset[1][1]= ( (-r*sprite_ref[0][1] + virtual_ref[0][1])*(-2*vop_ref[0][0] + 1) |
753 | 5417 +(-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][1] + 1) |
2967 | 5418 +2*w2*r*sprite_ref[0][1] |
753 | 5419 - 16*w2 |
5420 + (1<<(alpha+rho+1))); | |
5421 s->sprite_delta[0][0]= (-r*sprite_ref[0][0] + virtual_ref[0][0]); | |
5422 s->sprite_delta[0][1]= (+r*sprite_ref[0][1] - virtual_ref[0][1]); | |
5423 s->sprite_delta[1][0]= (-r*sprite_ref[0][1] + virtual_ref[0][1]); | |
5424 s->sprite_delta[1][1]= (-r*sprite_ref[0][0] + virtual_ref[0][0]); | |
2967 | 5425 |
753 | 5426 s->sprite_shift[0]= alpha+rho; |
5427 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
|
5428 break; |
753 | 5429 case 3: |
847 | 5430 min_ab= FFMIN(alpha, beta); |
753 | 5431 w3= w2>>min_ab; |
5432 h3= h2>>min_ab; | |
5433 s->sprite_offset[0][0]= (sprite_ref[0][0]<<(alpha+beta+rho-min_ab)) | |
5434 + (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3*(-vop_ref[0][0]) | |
5435 + (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3*(-vop_ref[0][1]) | |
5436 + (1<<(alpha+beta+rho-min_ab-1)); | |
5437 s->sprite_offset[0][1]= (sprite_ref[0][1]<<(alpha+beta+rho-min_ab)) | |
5438 + (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3*(-vop_ref[0][0]) | |
5439 + (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3*(-vop_ref[0][1]) | |
5440 + (1<<(alpha+beta+rho-min_ab-1)); | |
5441 s->sprite_offset[1][0]= (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3*(-2*vop_ref[0][0] + 1) | |
5442 + (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3*(-2*vop_ref[0][1] + 1) | |
5443 + 2*w2*h3*r*sprite_ref[0][0] | |
5444 - 16*w2*h3 | |
5445 + (1<<(alpha+beta+rho-min_ab+1)); | |
5446 s->sprite_offset[1][1]= (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3*(-2*vop_ref[0][0] + 1) | |
5447 + (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3*(-2*vop_ref[0][1] + 1) | |
5448 + 2*w2*h3*r*sprite_ref[0][1] | |
5449 - 16*w2*h3 | |
5450 + (1<<(alpha+beta+rho-min_ab+1)); | |
5451 s->sprite_delta[0][0]= (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3; | |
5452 s->sprite_delta[0][1]= (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3; | |
5453 s->sprite_delta[1][0]= (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3; | |
5454 s->sprite_delta[1][1]= (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3; | |
2967 | 5455 |
753 | 5456 s->sprite_shift[0]= alpha + beta + rho - min_ab; |
5457 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
|
5458 break; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5459 } |
2967 | 5460 /* try to simplify the situation */ |
753 | 5461 if( s->sprite_delta[0][0] == a<<s->sprite_shift[0] |
5462 && s->sprite_delta[0][1] == 0 | |
5463 && s->sprite_delta[1][0] == 0 | |
5464 && s->sprite_delta[1][1] == a<<s->sprite_shift[0]) | |
255 | 5465 { |
753 | 5466 s->sprite_offset[0][0]>>=s->sprite_shift[0]; |
5467 s->sprite_offset[0][1]>>=s->sprite_shift[0]; | |
5468 s->sprite_offset[1][0]>>=s->sprite_shift[1]; | |
5469 s->sprite_offset[1][1]>>=s->sprite_shift[1]; | |
5470 s->sprite_delta[0][0]= a; | |
5471 s->sprite_delta[0][1]= 0; | |
5472 s->sprite_delta[1][0]= 0; | |
5473 s->sprite_delta[1][1]= a; | |
5474 s->sprite_shift[0]= 0; | |
5475 s->sprite_shift[1]= 0; | |
255 | 5476 s->real_sprite_warping_points=1; |
5477 } | |
753 | 5478 else{ |
5479 int shift_y= 16 - s->sprite_shift[0]; | |
5480 int shift_c= 16 - s->sprite_shift[1]; | |
5481 //printf("shifts %d %d\n", shift_y, shift_c); | |
5482 for(i=0; i<2; i++){ | |
5483 s->sprite_offset[0][i]<<= shift_y; | |
5484 s->sprite_offset[1][i]<<= shift_c; | |
5485 s->sprite_delta[0][i]<<= shift_y; | |
5486 s->sprite_delta[1][i]<<= shift_y; | |
5487 s->sprite_shift[i]= 16; | |
5488 } | |
255 | 5489 s->real_sprite_warping_points= s->num_sprite_warping_points; |
753 | 5490 } |
5491 #if 0 | |
5492 printf("vop:%d:%d %d:%d %d:%d, sprite:%d:%d %d:%d %d:%d, virtual: %d:%d %d:%d\n", | |
5493 vop_ref[0][0], vop_ref[0][1], | |
5494 vop_ref[1][0], vop_ref[1][1], | |
5495 vop_ref[2][0], vop_ref[2][1], | |
2967 | 5496 sprite_ref[0][0], sprite_ref[0][1], |
5497 sprite_ref[1][0], sprite_ref[1][1], | |
5498 sprite_ref[2][0], sprite_ref[2][1], | |
5499 virtual_ref[0][0], virtual_ref[0][1], | |
753 | 5500 virtual_ref[1][0], virtual_ref[1][1] |
5501 ); | |
2967 | 5502 |
753 | 5503 printf("offset: %d:%d , delta: %d %d %d %d, shift %d\n", |
5504 s->sprite_offset[0][0], s->sprite_offset[0][1], | |
5505 s->sprite_delta[0][0], s->sprite_delta[0][1], | |
5506 s->sprite_delta[1][0], s->sprite_delta[1][1], | |
5507 s->sprite_shift[0] | |
5508 ); | |
5509 #endif | |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5510 } |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5511 |
942 | 5512 static int mpeg4_decode_gop_header(MpegEncContext * s, GetBitContext *gb){ |
5513 int hours, minutes, seconds; | |
5514 | |
5515 hours= get_bits(gb, 5); | |
5516 minutes= get_bits(gb, 6); | |
5517 skip_bits1(gb); | |
5518 seconds= get_bits(gb, 6); | |
5519 | |
5520 s->time_base= seconds + 60*(minutes + 60*hours); | |
5521 | |
5522 skip_bits1(gb); | |
5523 skip_bits1(gb); | |
2967 | 5524 |
942 | 5525 return 0; |
5526 } | |
5527 | |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5528 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
|
5529 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
|
5530 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5531 /* vol header */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5532 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
|
5533 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
|
5534 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
|
5535 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
|
5536 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
|
5537 } else { |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5538 vo_ver_id = 1; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5539 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5540 //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
|
5541 s->aspect_ratio_info= get_bits(gb, 4); |
2967 | 5542 if(s->aspect_ratio_info == FF_ASPECT_EXTENDED){ |
1548 | 5543 s->avctx->sample_aspect_ratio.num= get_bits(gb, 8); // par_width |
5544 s->avctx->sample_aspect_ratio.den= get_bits(gb, 8); // par_height | |
887 | 5545 }else{ |
1548 | 5546 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
|
5547 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5548 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5549 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
|
5550 int chroma_format= get_bits(gb, 2); |
8690 | 5551 if(chroma_format!=CHROMA_420){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5552 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
|
5553 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5554 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
|
5555 if(get_bits1(gb)){ /* vbv parameters */ |
2979 | 5556 get_bits(gb, 15); /* first_half_bitrate */ |
5557 skip_bits1(gb); /* marker */ | |
5558 get_bits(gb, 15); /* latter_half_bitrate */ | |
5559 skip_bits1(gb); /* marker */ | |
5560 get_bits(gb, 15); /* first_half_vbv_buffer_size */ | |
5561 skip_bits1(gb); /* marker */ | |
5562 get_bits(gb, 3); /* latter_half_vbv_buffer_size */ | |
5563 get_bits(gb, 11); /* first_half_vbv_occupancy */ | |
5564 skip_bits1(gb); /* marker */ | |
5565 get_bits(gb, 15); /* latter_half_vbv_occupancy */ | |
5566 skip_bits1(gb); /* marker */ | |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5567 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5568 }else{ |
2646
c735e3e60ca7
Even More spelling errors. patch by (Kevin Baragona <kevinmb500 gawab com)
michael
parents:
2639
diff
changeset
|
5569 // set low delay flag only once the smartest? low delay detection won't be overriden |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5570 if(s->picture_number==0) |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5571 s->low_delay=0; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5572 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5573 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5574 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
|
5575 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
|
5576 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
|
5577 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
|
5578 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
|
5579 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5580 |
1411 | 5581 check_marker(gb, "before time_increment_resolution"); |
2967 | 5582 |
2637 | 5583 s->avctx->time_base.den = get_bits(gb, 16); |
2812 | 5584 if(!s->avctx->time_base.den){ |
5585 av_log(s->avctx, AV_LOG_ERROR, "time_base.den==0\n"); | |
5586 return -1; | |
5587 } | |
2967 | 5588 |
2637 | 5589 s->time_increment_bits = av_log2(s->avctx->time_base.den - 1) + 1; |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5590 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
|
5591 s->time_increment_bits = 1; |
2967 | 5592 |
1411 | 5593 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
|
5594 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5595 if (get_bits1(gb) != 0) { /* fixed_vop_rate */ |
2637 | 5596 s->avctx->time_base.num = get_bits(gb, s->time_increment_bits); |
5597 }else | |
5598 s->avctx->time_base.num = 1; | |
5599 | |
2034 | 5600 s->t_frame=0; |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5601 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5602 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
|
5603 if (s->shape == RECT_SHAPE) { |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5604 skip_bits1(gb); /* marker */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5605 width = get_bits(gb, 13); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5606 skip_bits1(gb); /* marker */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5607 height = get_bits(gb, 13); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5608 skip_bits1(gb); /* marker */ |
8612 | 5609 if(width && height && !(s->width && s->codec_tag == AV_RL32("MP4S"))){ /* they should be non zero but who knows ... */ |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5610 s->width = width; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5611 s->height = height; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5612 // 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
|
5613 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5614 } |
2967 | 5615 |
5616 s->progressive_sequence= | |
1659 | 5617 s->progressive_frame= get_bits1(gb)^1; |
3192 | 5618 s->interlaced_dct=0; |
2967 | 5619 if(!get_bits1(gb) && (s->avctx->debug & FF_DEBUG_PICT_INFO)) |
1644 | 5620 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
|
5621 if (vo_ver_id == 1) { |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5622 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
|
5623 } else { |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5624 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
|
5625 } |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5626 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
|
5627 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
|
5628 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
|
5629 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
|
5630 skip_bits1(gb); /* marker */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5631 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
|
5632 skip_bits1(gb); /* marker */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5633 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
|
5634 skip_bits1(gb); /* marker */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5635 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
|
5636 skip_bits1(gb); /* marker */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5637 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5638 s->num_sprite_warping_points= get_bits(gb, 6); |
4930
655d25351bfc
fix possibly exploitable stack overflow with num_sprite_warping_points (found by reimar)
michael
parents:
4672
diff
changeset
|
5639 if(s->num_sprite_warping_points > 3){ |
655d25351bfc
fix possibly exploitable stack overflow with num_sprite_warping_points (found by reimar)
michael
parents:
4672
diff
changeset
|
5640 av_log(s->avctx, AV_LOG_ERROR, "%d sprite_warping_points\n", s->num_sprite_warping_points); |
655d25351bfc
fix possibly exploitable stack overflow with num_sprite_warping_points (found by reimar)
michael
parents:
4672
diff
changeset
|
5641 s->num_sprite_warping_points= 0; |
655d25351bfc
fix possibly exploitable stack overflow with num_sprite_warping_points (found by reimar)
michael
parents:
4672
diff
changeset
|
5642 return -1; |
655d25351bfc
fix possibly exploitable stack overflow with num_sprite_warping_points (found by reimar)
michael
parents:
4672
diff
changeset
|
5643 } |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5644 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
|
5645 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
|
5646 if(s->vol_sprite_usage==STATIC_SPRITE) |
2967 | 5647 s->low_latency_sprite= get_bits1(gb); |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5648 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5649 // FIXME sadct disable bit if verid!=1 && shape not rect |
2967 | 5650 |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5651 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
|
5652 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
|
5653 if(get_bits(gb, 4)!=8) av_log(s->avctx, AV_LOG_ERROR, "N-bit not supported\n"); /* bits_per_pixel */ |
2628
511e3afc43e1
Ministry of English Composition, reporting for duty (and the word is "skipped", not "skiped"; "skiped" would rhyme with "hyped")
melanson
parents:
2615
diff
changeset
|
5654 if(s->quant_precision!=5) av_log(s->avctx, AV_LOG_ERROR, "quant precision %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
|
5655 } else { |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5656 s->quant_precision = 5; |
0 | 5657 } |
2967 | 5658 |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5659 // 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
|
5660 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5661 if((s->mpeg_quant=get_bits1(gb))){ /* vol_quant_type */ |
1057 | 5662 int i, v; |
2967 | 5663 |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5664 /* load default matrixes */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5665 for(i=0; i<64; i++){ |
1092 | 5666 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
|
5667 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
|
5668 s->intra_matrix[j]= v; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5669 s->chroma_intra_matrix[j]= v; |
2967 | 5670 |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5671 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
|
5672 s->inter_matrix[j]= v; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5673 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
|
5674 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5675 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5676 /* load custom intra matrix */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5677 if(get_bits1(gb)){ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5678 int last=0; |
2979 | 5679 for(i=0; i<64; i++){ |
1057 | 5680 int j; |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5681 v= get_bits(gb, 8); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5682 if(v==0) break; |
2967 | 5683 |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5684 last= v; |
1092 | 5685 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
|
5686 s->intra_matrix[j]= v; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5687 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
|
5688 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5689 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5690 /* replicate last value */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5691 for(; i<64; i++){ |
2979 | 5692 int j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ]; |
1411 | 5693 s->intra_matrix[j]= last; |
5694 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
|
5695 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5696 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5697 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5698 /* load custom non intra matrix */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5699 if(get_bits1(gb)){ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5700 int last=0; |
2979 | 5701 for(i=0; i<64; i++){ |
1057 | 5702 int j; |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5703 v= get_bits(gb, 8); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5704 if(v==0) break; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5705 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5706 last= v; |
1092 | 5707 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
|
5708 s->inter_matrix[j]= v; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5709 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
|
5710 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5711 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5712 /* replicate last value */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5713 for(; i<64; i++){ |
2979 | 5714 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
|
5715 s->inter_matrix[j]= last; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5716 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
|
5717 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5718 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5719 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5720 // 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
|
5721 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5722 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5723 if(vo_ver_id != 1) |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5724 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
|
5725 else s->quarter_sample=0; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5726 |
8251
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5727 if(!get_bits1(gb)){ |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5728 int pos= get_bits_count(gb); |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5729 int estimation_method= get_bits(gb, 2); |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5730 if(estimation_method<2){ |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5731 if(!get_bits1(gb)){ |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5732 s->cplx_estimation_trash_i += 8*get_bits1(gb); //opaque |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5733 s->cplx_estimation_trash_i += 8*get_bits1(gb); //transparent |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5734 s->cplx_estimation_trash_i += 8*get_bits1(gb); //intra_cae |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5735 s->cplx_estimation_trash_i += 8*get_bits1(gb); //inter_cae |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5736 s->cplx_estimation_trash_i += 8*get_bits1(gb); //no_update |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5737 s->cplx_estimation_trash_i += 8*get_bits1(gb); //upampling |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5738 } |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5739 if(!get_bits1(gb)){ |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5740 s->cplx_estimation_trash_i += 8*get_bits1(gb); //intra_blocks |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5741 s->cplx_estimation_trash_p += 8*get_bits1(gb); //inter_blocks |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5742 s->cplx_estimation_trash_p += 8*get_bits1(gb); //inter4v_blocks |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5743 s->cplx_estimation_trash_i += 8*get_bits1(gb); //not coded blocks |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5744 } |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5745 if(!check_marker(gb, "in complexity estimation part 1")){ |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5746 skip_bits_long(gb, pos - get_bits_count(gb)); |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5747 goto no_cplx_est; |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5748 } |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5749 if(!get_bits1(gb)){ |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5750 s->cplx_estimation_trash_i += 8*get_bits1(gb); //dct_coeffs |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5751 s->cplx_estimation_trash_i += 8*get_bits1(gb); //dct_lines |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5752 s->cplx_estimation_trash_i += 8*get_bits1(gb); //vlc_syms |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5753 s->cplx_estimation_trash_i += 4*get_bits1(gb); //vlc_bits |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5754 } |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5755 if(!get_bits1(gb)){ |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5756 s->cplx_estimation_trash_p += 8*get_bits1(gb); //apm |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5757 s->cplx_estimation_trash_p += 8*get_bits1(gb); //npm |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5758 s->cplx_estimation_trash_b += 8*get_bits1(gb); //interpolate_mc_q |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5759 s->cplx_estimation_trash_p += 8*get_bits1(gb); //forwback_mc_q |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5760 s->cplx_estimation_trash_p += 8*get_bits1(gb); //halfpel2 |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5761 s->cplx_estimation_trash_p += 8*get_bits1(gb); //halfpel4 |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5762 } |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5763 if(!check_marker(gb, "in complexity estimation part 2")){ |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5764 skip_bits_long(gb, pos - get_bits_count(gb)); |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5765 goto no_cplx_est; |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5766 } |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5767 if(estimation_method==1){ |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5768 s->cplx_estimation_trash_i += 8*get_bits1(gb); //sadct |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5769 s->cplx_estimation_trash_p += 8*get_bits1(gb); //qpel |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5770 } |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5771 }else |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5772 av_log(s->avctx, AV_LOG_ERROR, "Invalid Complexity estimation method %d\n", estimation_method); |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5773 }else{ |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5774 no_cplx_est: |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5775 s->cplx_estimation_trash_i= |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5776 s->cplx_estimation_trash_p= |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5777 s->cplx_estimation_trash_b= 0; |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5778 } |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5779 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5780 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
|
5781 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5782 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
|
5783 if(s->data_partitioning){ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5784 s->rvlc= get_bits1(gb); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5785 } |
2967 | 5786 |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5787 if(vo_ver_id != 1) { |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5788 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
|
5789 if(s->new_pred){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5790 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
|
5791 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
|
5792 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
|
5793 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5794 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
|
5795 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
|
5796 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5797 else{ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5798 s->new_pred=0; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5799 s->reduced_res_vop= 0; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5800 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5801 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5802 s->scalability= get_bits1(gb); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5803 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5804 if (s->scalability) { |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5805 GetBitContext bak= *gb; |
751 | 5806 int ref_layer_id; |
5807 int ref_layer_sampling_dir; | |
5808 int h_sampling_factor_n; | |
5809 int h_sampling_factor_m; | |
5810 int v_sampling_factor_n; | |
5811 int v_sampling_factor_m; | |
2967 | 5812 |
751 | 5813 s->hierachy_type= get_bits1(gb); |
5814 ref_layer_id= get_bits(gb, 4); | |
5815 ref_layer_sampling_dir= get_bits1(gb); | |
5816 h_sampling_factor_n= get_bits(gb, 5); | |
5817 h_sampling_factor_m= get_bits(gb, 5); | |
5818 v_sampling_factor_n= get_bits(gb, 5); | |
5819 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
|
5820 s->enhancement_type= get_bits1(gb); |
2967 | 5821 |
5822 if( h_sampling_factor_n==0 || h_sampling_factor_m==0 | |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5823 || v_sampling_factor_n==0 || v_sampling_factor_m==0){ |
2967 | 5824 |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5825 // 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
|
5826 s->scalability=0; |
2967 | 5827 |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5828 *gb= bak; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5829 }else |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5830 av_log(s->avctx, AV_LOG_ERROR, "scalability not supported\n"); |
2967 | 5831 |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5832 // bin shape stuff FIXME |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5833 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5834 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5835 return 0; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5836 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5837 |
1034 | 5838 /** |
5839 * decodes the user data stuff in the header. | |
6918 | 5840 * Also initializes divx/xvid/lavc_version/build. |
1034 | 5841 */ |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5842 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
|
5843 char buf[256]; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5844 int i; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5845 int e; |
2966
564788471dd4
bitstream related fixes from [PATCH] from DivX, Part 9: bitstream crashes by (Steve Lhomme | slhomme divxcorp com)
michael
parents:
2962
diff
changeset
|
5846 int ver = 0, build = 0, ver2 = 0, ver3 = 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
|
5847 char last; |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5848 |
3615 | 5849 for(i=0; i<255 && get_bits_count(gb) < gb->size_in_bits; i++){ |
2804 | 5850 if(show_bits(gb, 23) == 0) break; |
5851 buf[i]= get_bits(gb, 8); | |
5852 } | |
5853 buf[i]=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
|
5854 |
761 | 5855 /* 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
|
5856 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
|
5857 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
|
5858 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
|
5859 if(e>=2){ |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5860 s->divx_version= ver; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5861 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
|
5862 s->divx_packed= e==3 && last=='p'; |
8106
2f5101a67500
Only warn about "Invalid and inefficient vfw-avi packed B frames" once.
andoma
parents:
8042
diff
changeset
|
5863 if(s->divx_packed && !s->showed_packed_warning) { |
6893
72dafc993490
Warn about packed B-frames. (especially useful if the file in question is
michael
parents:
6655
diff
changeset
|
5864 av_log(s->avctx, AV_LOG_WARNING, "Invalid and inefficient vfw-avi packed B frames detected\n"); |
8106
2f5101a67500
Only warn about "Invalid and inefficient vfw-avi packed B frames" once.
andoma
parents:
8042
diff
changeset
|
5865 s->showed_packed_warning=1; |
2f5101a67500
Only warn about "Invalid and inefficient vfw-avi packed B frames" once.
andoma
parents:
8042
diff
changeset
|
5866 } |
0 | 5867 } |
2967 | 5868 |
761 | 5869 /* ffmpeg detection */ |
2805
55a6659fc2ee
fix user data parsing code so it suppors pre1 and cvs
michael
parents:
2804
diff
changeset
|
5870 e=sscanf(buf, "FFmpe%*[^b]b%d", &build)+3; |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5871 if(e!=4) |
2967 | 5872 e=sscanf(buf, "FFmpeg v%d.%d.%d / libavcodec build: %d", &ver, &ver2, &ver3, &build); |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5873 if(e!=4){ |
2814 | 5874 e=sscanf(buf, "Lavc%d.%d.%d", &ver, &ver2, &ver3)+1; |
2966
564788471dd4
bitstream related fixes from [PATCH] from DivX, Part 9: bitstream crashes by (Steve Lhomme | slhomme divxcorp com)
michael
parents:
2962
diff
changeset
|
5875 if (e>1) |
564788471dd4
bitstream related fixes from [PATCH] from DivX, Part 9: bitstream crashes by (Steve Lhomme | slhomme divxcorp com)
michael
parents:
2962
diff
changeset
|
5876 build= (ver<<16) + (ver2<<8) + ver3; |
2814 | 5877 } |
5878 if(e!=4){ | |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5879 if(strcmp(buf, "ffmpeg")==0){ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5880 s->lavc_build= 4600; |
63 | 5881 } |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5882 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5883 if(e==4){ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5884 s->lavc_build= build; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5885 } |
2967 | 5886 |
6908 | 5887 /* Xvid detection */ |
761 | 5888 e=sscanf(buf, "XviD%d", &build); |
5889 if(e==1){ | |
5890 s->xvid_build= build; | |
5891 } | |
5892 | |
255 | 5893 //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
|
5894 return 0; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5895 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5896 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5897 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
|
5898 int time_incr, time_increment; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5899 |
6481 | 5900 s->pict_type = get_bits(gb, 2) + FF_I_TYPE; /* pict type: I = 0 , P = 1 */ |
5901 if(s->pict_type==FF_B_TYPE && s->low_delay && s->vol_control_parameters==0 && !(s->flags & CODEC_FLAG_LOW_DELAY)){ | |
2628
511e3afc43e1
Ministry of English Composition, reporting for duty (and the word is "skipped", not "skiped"; "skiped" would rhyme with "hyped")
melanson
parents:
2615
diff
changeset
|
5902 av_log(s->avctx, AV_LOG_ERROR, "low_delay flag incorrectly, clearing it\n"); |
365
fdeec2834c79
there are divx5? encoded files without a userdata section but with b-frames :(
michaelni
parents:
364
diff
changeset
|
5903 s->low_delay=0; |
fdeec2834c79
there are divx5? encoded files without a userdata section but with b-frames :(
michaelni
parents:
364
diff
changeset
|
5904 } |
2967 | 5905 |
6481 | 5906 s->partitioned_frame= s->data_partitioning && s->pict_type!=FF_B_TYPE; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
5907 if(s->partitioned_frame) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
5908 s->decode_mb= mpeg4_decode_partitioned_mb; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
5909 else |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
5910 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
|
5911 |
262 | 5912 time_incr=0; |
2967 | 5913 while (get_bits1(gb) != 0) |
0 | 5914 time_incr++; |
5915 | |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5916 check_marker(gb, "before time_increment"); |
2666 | 5917 |
5918 if(s->time_increment_bits==0 || !(show_bits(gb, s->time_increment_bits+1)&1)){ | |
2628
511e3afc43e1
Ministry of English Composition, reporting for duty (and the word is "skipped", not "skiped"; "skiped" would rhyme with "hyped")
melanson
parents:
2615
diff
changeset
|
5919 av_log(s->avctx, AV_LOG_ERROR, "hmm, seems the headers are not complete, trying to guess time_increment_bits\n"); |
1068 | 5920 |
5921 for(s->time_increment_bits=1 ;s->time_increment_bits<16; s->time_increment_bits++){ | |
5922 if(show_bits(gb, s->time_increment_bits+1)&1) break; | |
5923 } | |
1396 | 5924 |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5925 av_log(s->avctx, AV_LOG_ERROR, "my guess is %d bits ;)\n",s->time_increment_bits); |
1068 | 5926 } |
2967 | 5927 |
1411 | 5928 if(IS_3IV1) time_increment= get_bits1(gb); //FIXME investigate further |
5929 else time_increment= get_bits(gb, s->time_increment_bits); | |
2967 | 5930 |
1411 | 5931 // printf("%d %X\n", s->time_increment_bits, time_increment); |
2034 | 5932 //av_log(s->avctx, AV_LOG_DEBUG, " type:%d modulo_time_base:%d increment:%d t_frame %d\n", s->pict_type, time_incr, time_increment, s->t_frame); |
6481 | 5933 if(s->pict_type!=FF_B_TYPE){ |
324 | 5934 s->last_time_base= s->time_base; |
262 | 5935 s->time_base+= time_incr; |
2637 | 5936 s->time= s->time_base*s->avctx->time_base.den + time_increment; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
5937 if(s->workaround_bugs&FF_BUG_UMP4){ |
700
0fb4c66527e1
autodetect UMP4 (by adding a fourcc field to AVCodecContext)
michaelni
parents:
699
diff
changeset
|
5938 if(s->time < s->last_non_b_time){ |
0fb4c66527e1
autodetect UMP4 (by adding a fourcc field to AVCodecContext)
michaelni
parents:
699
diff
changeset
|
5939 // 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
|
5940 s->time_base++; |
2637 | 5941 s->time+= s->avctx->time_base.den; |
700
0fb4c66527e1
autodetect UMP4 (by adding a fourcc field to AVCodecContext)
michaelni
parents:
699
diff
changeset
|
5942 } |
664 | 5943 } |
324 | 5944 s->pp_time= s->time - s->last_non_b_time; |
5945 s->last_non_b_time= s->time; | |
262 | 5946 }else{ |
2637 | 5947 s->time= (s->last_time_base + time_incr)*s->avctx->time_base.den + time_increment; |
664 | 5948 s->pb_time= s->pp_time - (s->last_non_b_time - s->time); |
5949 if(s->pp_time <=s->pb_time || s->pp_time <= s->pp_time - s->pb_time || s->pp_time<=0){ | |
2628
511e3afc43e1
Ministry of English Composition, reporting for duty (and the word is "skipped", not "skiped"; "skiped" would rhyme with "hyped")
melanson
parents:
2615
diff
changeset
|
5950 // printf("messed up order, maybe after seeking? skipping current b frame\n"); |
511e3afc43e1
Ministry of English Composition, reporting for duty (and the word is "skipped", not "skiped"; "skiped" would rhyme with "hyped")
melanson
parents:
2615
diff
changeset
|
5951 return FRAME_SKIPPED; |
335 | 5952 } |
3247 | 5953 ff_mpeg4_init_direct_mv(s); |
2967 | 5954 |
2034 | 5955 if(s->t_frame==0) s->t_frame= s->pb_time; |
664 | 5956 if(s->t_frame==0) s->t_frame=1; // 1/0 protection |
2967 | 5957 s->pp_field_time= ( ROUNDED_DIV(s->last_non_b_time, s->t_frame) |
664 | 5958 - ROUNDED_DIV(s->last_non_b_time - s->pp_time, s->t_frame))*2; |
2967 | 5959 s->pb_field_time= ( ROUNDED_DIV(s->time, s->t_frame) |
664 | 5960 - ROUNDED_DIV(s->last_non_b_time - s->pp_time, s->t_frame))*2; |
4346 | 5961 if(!s->progressive_sequence){ |
5962 if(s->pp_field_time <= s->pb_field_time || s->pb_field_time <= 1) | |
5963 return FRAME_SKIPPED; | |
5964 } | |
262 | 5965 } |
4122
daae66c03857
Replace most of the %lld and %llx by their (cleaner) PRI*64 counterparts.
diego
parents:
4001
diff
changeset
|
5966 //av_log(s->avctx, AV_LOG_DEBUG, "last nonb %"PRId64" last_base %d time %"PRId64" pp %d pb %d t %d ppf %d pbf %d\n", s->last_non_b_time, s->last_time_base, s->time, s->pp_time, s->pb_time, s->t_frame, s->pp_field_time, s->pb_field_time); |
2967 | 5967 |
2813
6fd9dbb8c385
try to check for nonsense time_base instead of setting fake one
michael
parents:
2812
diff
changeset
|
5968 if(s->avctx->time_base.num) |
6fd9dbb8c385
try to check for nonsense time_base instead of setting fake one
michael
parents:
2812
diff
changeset
|
5969 s->current_picture_ptr->pts= (s->time + s->avctx->time_base.num/2) / s->avctx->time_base.num; |
6fd9dbb8c385
try to check for nonsense time_base instead of setting fake one
michael
parents:
2812
diff
changeset
|
5970 else |
6fd9dbb8c385
try to check for nonsense time_base instead of setting fake one
michael
parents:
2812
diff
changeset
|
5971 s->current_picture_ptr->pts= AV_NOPTS_VALUE; |
942 | 5972 if(s->avctx->debug&FF_DEBUG_PTS) |
2962 | 5973 av_log(s->avctx, AV_LOG_DEBUG, "MPEG4 PTS: %"PRId64"\n", s->current_picture_ptr->pts); |
2034 | 5974 |
1068 | 5975 check_marker(gb, "before vop_coded"); |
2967 | 5976 |
0 | 5977 /* vop coded */ |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5978 if (get_bits1(gb) != 1){ |
2271 | 5979 if(s->avctx->debug&FF_DEBUG_PICT_INFO) |
5980 av_log(s->avctx, AV_LOG_ERROR, "vop not coded\n"); | |
2628
511e3afc43e1
Ministry of English Composition, reporting for duty (and the word is "skipped", not "skiped"; "skiped" would rhyme with "hyped")
melanson
parents:
2615
diff
changeset
|
5981 return FRAME_SKIPPED; |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5982 } |
4122
daae66c03857
Replace most of the %lld and %llx by their (cleaner) PRI*64 counterparts.
diego
parents:
4001
diff
changeset
|
5983 //printf("time %d %d %d || %"PRId64" %"PRId64" %"PRId64"\n", s->time_increment_bits, s->avctx->time_base.den, s->time_base, |
2967 | 5984 //s->time, s->last_non_b_time, s->last_non_b_time - s->pp_time); |
6481 | 5985 if (s->shape != BIN_ONLY_SHAPE && ( s->pict_type == FF_P_TYPE |
5986 || (s->pict_type == FF_S_TYPE && s->vol_sprite_usage==GMC_SPRITE))) { | |
0 | 5987 /* rounding type for motion estimation */ |
2979 | 5988 s->no_rounding = get_bits1(gb); |
63 | 5989 } else { |
2979 | 5990 s->no_rounding = 0; |
0 | 5991 } |
253
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
5992 //FIXME reduced res stuff |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
5993 |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
5994 if (s->shape != RECT_SHAPE) { |
6481 | 5995 if (s->vol_sprite_usage != 1 || s->pict_type != FF_I_TYPE) { |
63 | 5996 int width, height, hor_spat_ref, ver_spat_ref; |
2967 | 5997 |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5998 width = get_bits(gb, 13); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5999 skip_bits1(gb); /* marker */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6000 height = get_bits(gb, 13); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6001 skip_bits1(gb); /* marker */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6002 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
|
6003 skip_bits1(gb); /* marker */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6004 ver_spat_ref = get_bits(gb, 13); /* ver_spat_ref */ |
63 | 6005 } |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6006 skip_bits1(gb); /* change_CR_disable */ |
2967 | 6007 |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6008 if (get_bits1(gb) != 0) { |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6009 skip_bits(gb, 8); /* constant_alpha_value */ |
63 | 6010 } |
6011 } | |
253
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
6012 //FIXME complexity estimation stuff |
2967 | 6013 |
253
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
6014 if (s->shape != BIN_ONLY_SHAPE) { |
8251
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
6015 skip_bits_long(gb, s->cplx_estimation_trash_i); |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
6016 if(s->pict_type != FF_I_TYPE) |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
6017 skip_bits_long(gb, s->cplx_estimation_trash_p); |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
6018 if(s->pict_type == FF_B_TYPE) |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
6019 skip_bits_long(gb, s->cplx_estimation_trash_b); |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
6020 |
1520 | 6021 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
|
6022 if(!s->progressive_sequence){ |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6023 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
|
6024 s->alternate_scan= get_bits1(gb); |
661 | 6025 }else |
6026 s->alternate_scan= 0; | |
253
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
6027 } |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
6028 |
718 | 6029 if(s->alternate_scan){ |
1273 | 6030 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_alternate_vertical_scan); |
6031 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_alternate_vertical_scan); | |
6032 ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_vertical_scan); | |
6033 ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan); | |
718 | 6034 } else{ |
1273 | 6035 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_zigzag_direct); |
6036 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_zigzag_direct); | |
6037 ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan); | |
6038 ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan); | |
718 | 6039 } |
2967 | 6040 |
6481 | 6041 if(s->pict_type == FF_S_TYPE && (s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE)){ |
1914 | 6042 mpeg4_decode_sprite_trajectory(s, gb); |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
6043 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
|
6044 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
|
6045 } |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
6046 |
253
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
6047 if (s->shape != BIN_ONLY_SHAPE) { |
1644 | 6048 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
|
6049 if(s->qscale==0){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
6050 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
|
6051 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
|
6052 } |
2967 | 6053 |
6481 | 6054 if (s->pict_type != FF_I_TYPE) { |
2979 | 6055 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
|
6056 if(s->f_code==0){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
6057 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
|
6058 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
|
6059 } |
582
5132a4ee50cd
different edge positions fixed with edge emu / dr1
michaelni
parents:
575
diff
changeset
|
6060 }else |
5132a4ee50cd
different edge positions fixed with edge emu / dr1
michaelni
parents:
575
diff
changeset
|
6061 s->f_code=1; |
2967 | 6062 |
6481 | 6063 if (s->pict_type == FF_B_TYPE) { |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6064 s->b_code = get_bits(gb, 3); |
582
5132a4ee50cd
different edge positions fixed with edge emu / dr1
michaelni
parents:
575
diff
changeset
|
6065 }else |
5132a4ee50cd
different edge positions fixed with edge emu / dr1
michaelni
parents:
575
diff
changeset
|
6066 s->b_code=1; |
906 | 6067 |
6068 if(s->avctx->debug&FF_DEBUG_PICT_INFO){ | |
8251
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
6069 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 ce:%d/%d/%d\n", |
2967 | 6070 s->qscale, s->f_code, s->b_code, |
6481 | 6071 s->pict_type == FF_I_TYPE ? "I" : (s->pict_type == FF_P_TYPE ? "P" : (s->pict_type == FF_B_TYPE ? "B" : "S")), |
2967 | 6072 gb->size_in_bits,s->progressive_sequence, s->alternate_scan, s->top_field_first, |
930 | 6073 s->quarter_sample ? "q" : "h", s->data_partitioning, s->resync_marker, s->num_sprite_warping_points, |
8251
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
6074 s->sprite_warping_accuracy, 1-s->no_rounding, s->vo_type, s->vol_control_parameters ? " VOLC" : " ", s->intra_dc_threshold, s->cplx_estimation_trash_i, s->cplx_estimation_trash_p, s->cplx_estimation_trash_b); |
906 | 6075 } |
6076 | |
253
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
6077 if(!s->scalability){ |
6481 | 6078 if (s->shape!=RECT_SHAPE && s->pict_type!=FF_I_TYPE) { |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6079 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
|
6080 } |
575 | 6081 }else{ |
6082 if(s->enhancement_type){ | |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6083 int load_backward_shape= get_bits1(gb); |
575 | 6084 if(load_backward_shape){ |
2646
c735e3e60ca7
Even More spelling errors. patch by (Kevin Baragona <kevinmb500 gawab com)
michael
parents:
2639
diff
changeset
|
6085 av_log(s->avctx, AV_LOG_ERROR, "load backward shape isn't supported\n"); |
575 | 6086 } |
6087 } | |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6088 skip_bits(gb, 2); //ref_select_code |
63 | 6089 } |
6090 } | |
2646
c735e3e60ca7
Even More spelling errors. patch by (Kevin Baragona <kevinmb500 gawab com)
michael
parents:
2639
diff
changeset
|
6091 /* detect buggy encoders which don't set the low_delay flag (divx4/xvid/opendivx)*/ |
c735e3e60ca7
Even More spelling errors. patch by (Kevin Baragona <kevinmb500 gawab com)
michael
parents:
2639
diff
changeset
|
6092 // note we cannot detect divx5 without b-frames easily (although it's buggy too) |
365
fdeec2834c79
there are divx5? encoded files without a userdata section but with b-frames :(
michaelni
parents:
364
diff
changeset
|
6093 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
|
6094 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
|
6095 s->low_delay=1; |
c2f789fe4945
detecting xvid/divx4/opendivx and set low_delay flag
michaelni
parents:
344
diff
changeset
|
6096 } |
c2f789fe4945
detecting xvid/divx4/opendivx and set low_delay flag
michaelni
parents:
344
diff
changeset
|
6097 |
2646
c735e3e60ca7
Even More spelling errors. patch by (Kevin Baragona <kevinmb500 gawab com)
michael
parents:
2639
diff
changeset
|
6098 s->picture_number++; // better than pic number==0 always ;) |
346
c2f789fe4945
detecting xvid/divx4/opendivx and set low_delay flag
michaelni
parents:
344
diff
changeset
|
6099 |
2967 | 6100 s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table; //FIXME add short header support |
498 | 6101 s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table; |
6102 | |
1366
80067f8d6770
fix edge repeating bug for %16!=0 files, this fixes Quicktime mpeg4 (they arent buggy)
michaelni
parents:
1364
diff
changeset
|
6103 if(s->workaround_bugs&FF_BUG_EDGE){ |
582
5132a4ee50cd
different edge positions fixed with edge emu / dr1
michaelni
parents:
575
diff
changeset
|
6104 s->h_edge_pos= s->width; |
5132a4ee50cd
different edge positions fixed with edge emu / dr1
michaelni
parents:
575
diff
changeset
|
6105 s->v_edge_pos= s->height; |
5132a4ee50cd
different edge positions fixed with edge emu / dr1
michaelni
parents:
575
diff
changeset
|
6106 } |
63 | 6107 return 0; |
0 | 6108 } |
6109 | |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6110 /** |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6111 * decode mpeg4 headers |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6112 * @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
|
6113 * 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
|
6114 * 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
|
6115 */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6116 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
|
6117 { |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6118 int startcode, v; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6119 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6120 /* search next start code */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6121 align_get_bits(gb); |
2406 | 6122 |
8612 | 6123 if(s->codec_tag == AV_RL32("WV1F") && show_bits(gb, 24) == 0x575630){ |
2406 | 6124 skip_bits(gb, 24); |
6125 if(get_bits(gb, 8) == 0xF0) | |
8417
ad4f10287633
Move CODEC_FLAG_LOW_DELAY into ff_mpeg4_decode_picture_header().
michael
parents:
8297
diff
changeset
|
6126 goto end; |
2406 | 6127 } |
6128 | |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6129 startcode = 0xff; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6130 for(;;) { |
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
|
6131 if(get_bits_count(gb) >= gb->size_in_bits){ |
2554
84a8f374bf63
fixing playback of xvid pretending to be divx (sample_vop_nc.avi)
michael
parents:
2522
diff
changeset
|
6132 if(gb->size_in_bits==8 && (s->divx_version || s->xvid_build)){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
6133 av_log(s->avctx, AV_LOG_ERROR, "frame skip %d\n", gb->size_in_bits); |
2628
511e3afc43e1
Ministry of English Composition, reporting for duty (and the word is "skipped", not "skiped"; "skiped" would rhyme with "hyped")
melanson
parents:
2615
diff
changeset
|
6134 return FRAME_SKIPPED; //divx bug |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6135 }else |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6136 return -1; //end of stream |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6137 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6138 |
2966
564788471dd4
bitstream related fixes from [PATCH] from DivX, Part 9: bitstream crashes by (Steve Lhomme | slhomme divxcorp com)
michael
parents:
2962
diff
changeset
|
6139 /* use the bits after the test */ |
564788471dd4
bitstream related fixes from [PATCH] from DivX, Part 9: bitstream crashes by (Steve Lhomme | slhomme divxcorp com)
michael
parents:
2962
diff
changeset
|
6140 v = get_bits(gb, 8); |
564788471dd4
bitstream related fixes from [PATCH] from DivX, Part 9: bitstream crashes by (Steve Lhomme | slhomme divxcorp com)
michael
parents:
2962
diff
changeset
|
6141 startcode = ((startcode << 8) | v) & 0xffffffff; |
564788471dd4
bitstream related fixes from [PATCH] from DivX, Part 9: bitstream crashes by (Steve Lhomme | slhomme divxcorp com)
michael
parents:
2962
diff
changeset
|
6142 |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6143 if((startcode&0xFFFFFF00) != 0x100) |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6144 continue; //no startcode |
2967 | 6145 |
942 | 6146 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
|
6147 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
|
6148 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
|
6149 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
|
6150 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
|
6151 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
|
6152 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
|
6153 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
|
6154 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
|
6155 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
|
6156 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
|
6157 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
|
6158 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
|
6159 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
|
6160 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
|
6161 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
|
6162 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
|
6163 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
|
6164 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
|
6165 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
|
6166 else if(startcode==0x1BD) av_log(s->avctx, AV_LOG_DEBUG, "Mesh Object Plane start"); |
2628
511e3afc43e1
Ministry of English Composition, reporting for duty (and the word is "skipped", not "skiped"; "skiped" would rhyme with "hyped")
melanson
parents:
2615
diff
changeset
|
6167 else if(startcode==0x1BE) av_log(s->avctx, AV_LOG_DEBUG, "Still Texture Object start"); |
511e3afc43e1
Ministry of English Composition, reporting for duty (and the word is "skipped", not "skiped"; "skiped" would rhyme with "hyped")
melanson
parents:
2615
diff
changeset
|
6168 else if(startcode==0x1BF) av_log(s->avctx, AV_LOG_DEBUG, "Texture Spatial Layer start"); |
511e3afc43e1
Ministry of English Composition, reporting for duty (and the word is "skipped", not "skiped"; "skiped" would rhyme with "hyped")
melanson
parents:
2615
diff
changeset
|
6169 else if(startcode==0x1C0) av_log(s->avctx, AV_LOG_DEBUG, "Texture SNR Layer start"); |
511e3afc43e1
Ministry of English Composition, reporting for duty (and the word is "skipped", not "skiped"; "skiped" would rhyme with "hyped")
melanson
parents:
2615
diff
changeset
|
6170 else if(startcode==0x1C1) av_log(s->avctx, AV_LOG_DEBUG, "Texture Tile start"); |
511e3afc43e1
Ministry of English Composition, reporting for duty (and the word is "skipped", not "skiped"; "skiped" would rhyme with "hyped")
melanson
parents:
2615
diff
changeset
|
6171 else if(startcode==0x1C2) av_log(s->avctx, AV_LOG_DEBUG, "Texture Shape Layer start"); |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
6172 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
|
6173 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
|
6174 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
|
6175 av_log(s->avctx, AV_LOG_DEBUG, " at %d\n", get_bits_count(gb)); |
942 | 6176 } |
6177 | |
1512 | 6178 if(startcode >= 0x120 && startcode <= 0x12F){ |
2967 | 6179 if(decode_vol_header(s, gb) < 0) |
1396 | 6180 return -1; |
1512 | 6181 } |
6182 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
|
6183 decode_user_data(s, gb); |
1512 | 6184 } |
6185 else if(startcode == GOP_STARTCODE){ | |
942 | 6186 mpeg4_decode_gop_header(s, gb); |
1512 | 6187 } |
6188 else if(startcode == VOP_STARTCODE){ | |
8417
ad4f10287633
Move CODEC_FLAG_LOW_DELAY into ff_mpeg4_decode_picture_header().
michael
parents:
8297
diff
changeset
|
6189 break; |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6190 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6191 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6192 align_get_bits(gb); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6193 startcode = 0xff; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6194 } |
8417
ad4f10287633
Move CODEC_FLAG_LOW_DELAY into ff_mpeg4_decode_picture_header().
michael
parents:
8297
diff
changeset
|
6195 end: |
ad4f10287633
Move CODEC_FLAG_LOW_DELAY into ff_mpeg4_decode_picture_header().
michael
parents:
8297
diff
changeset
|
6196 if(s->flags& CODEC_FLAG_LOW_DELAY) |
ad4f10287633
Move CODEC_FLAG_LOW_DELAY into ff_mpeg4_decode_picture_header().
michael
parents:
8297
diff
changeset
|
6197 s->low_delay=1; |
8418
f75be04312dc
Fix PTS returned by the demuxers for mpeg4 without a decoder.
michael
parents:
8417
diff
changeset
|
6198 s->avctx->has_b_frames= !s->low_delay; |
8417
ad4f10287633
Move CODEC_FLAG_LOW_DELAY into ff_mpeg4_decode_picture_header().
michael
parents:
8297
diff
changeset
|
6199 return decode_vop_header(s, gb); |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6200 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6201 |
0 | 6202 /* don't understand why they choose a different header ! */ |
6203 int intel_h263_decode_picture_header(MpegEncContext *s) | |
6204 { | |
6205 int format; | |
6206 | |
6207 /* picture header */ | |
1257 | 6208 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
|
6209 av_log(s->avctx, AV_LOG_ERROR, "Bad picture start code\n"); |
0 | 6210 return -1; |
355 | 6211 } |
6212 s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */ | |
0 | 6213 |
355 | 6214 if (get_bits1(&s->gb) != 1) { |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
6215 av_log(s->avctx, AV_LOG_ERROR, "Bad marker\n"); |
2979 | 6216 return -1; /* marker */ |
355 | 6217 } |
6218 if (get_bits1(&s->gb) != 0) { | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
6219 av_log(s->avctx, AV_LOG_ERROR, "Bad H263 id\n"); |
2979 | 6220 return -1; /* h263 id */ |
6221 } | |
6222 skip_bits1(&s->gb); /* split screen off */ | |
6223 skip_bits1(&s->gb); /* camera off */ | |
6224 skip_bits1(&s->gb); /* freeze picture release off */ | |
0 | 6225 |
6226 format = get_bits(&s->gb, 3); | |
355 | 6227 if (format != 7) { |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
6228 av_log(s->avctx, AV_LOG_ERROR, "Intel H263 free format not supported\n"); |
0 | 6229 return -1; |
355 | 6230 } |
0 | 6231 s->h263_plus = 0; |
6232 | |
6481 | 6233 s->pict_type = FF_I_TYPE + get_bits1(&s->gb); |
2967 | 6234 |
6235 s->unrestricted_mv = get_bits1(&s->gb); | |
0 | 6236 s->h263_long_vectors = s->unrestricted_mv; |
6237 | |
355 | 6238 if (get_bits1(&s->gb) != 0) { |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
6239 av_log(s->avctx, AV_LOG_ERROR, "SAC not supported\n"); |
2979 | 6240 return -1; /* SAC: off */ |
355 | 6241 } |
5405
f15e5b4909e1
remove "Advanced Prediction Mode not supported" spam
michael
parents:
5404
diff
changeset
|
6242 s->obmc= get_bits1(&s->gb); |
9008 | 6243 s->pb_frame = get_bits1(&s->gb); |
6244 | |
6245 if(format == 7){ | |
6246 format = get_bits(&s->gb, 3); | |
6247 if(format == 0 || format == 7){ | |
6248 av_log(s->avctx, AV_LOG_ERROR, "Wrong Intel H263 format\n"); | |
6249 return -1; | |
6250 } | |
6251 if(get_bits(&s->gb, 2)) | |
6252 av_log(s->avctx, AV_LOG_ERROR, "Bad value for reserved field\n"); | |
6253 s->loop_filter = get_bits1(&s->gb); | |
6254 if(get_bits1(&s->gb)) | |
6255 av_log(s->avctx, AV_LOG_ERROR, "Bad value for reserved field\n"); | |
6256 if(get_bits1(&s->gb)) | |
6257 s->pb_frame = 2; | |
6258 if(get_bits(&s->gb, 5)) | |
6259 av_log(s->avctx, AV_LOG_ERROR, "Bad value for reserved field\n"); | |
6260 if(get_bits(&s->gb, 5) != 1) | |
6261 av_log(s->avctx, AV_LOG_ERROR, "Invalid marker\n"); | |
6262 } | |
6263 if(format == 6){ | |
6264 int ar = get_bits(&s->gb, 4); | |
6265 skip_bits(&s->gb, 9); // display width | |
6266 skip_bits1(&s->gb); | |
6267 skip_bits(&s->gb, 9); // display height | |
6268 if(ar == 15){ | |
6269 skip_bits(&s->gb, 8); // aspect ratio - width | |
6270 skip_bits(&s->gb, 8); // aspect ratio - height | |
6271 } | |
6272 } | |
0 | 6273 |
1644 | 6274 s->chroma_qscale= s->qscale = get_bits(&s->gb, 5); |
2979 | 6275 skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */ |
0 | 6276 |
9008 | 6277 if(s->pb_frame){ |
6278 skip_bits(&s->gb, 3); //temporal reference for B-frame | |
6279 skip_bits(&s->gb, 2); //dbquant | |
6280 } | |
6281 | |
0 | 6282 /* PEI */ |
21 | 6283 while (get_bits1(&s->gb) != 0) { |
6284 skip_bits(&s->gb, 8); | |
0 | 6285 } |
6286 s->f_code = 1; | |
770
d1770a34e4f6
segfault fix patch by (Juergen Keil <jk at tools dot de>)
michaelni
parents:
766
diff
changeset
|
6287 |
d1770a34e4f6
segfault fix patch by (Juergen Keil <jk at tools dot de>)
michaelni
parents:
766
diff
changeset
|
6288 s->y_dc_scale_table= |
d1770a34e4f6
segfault fix patch by (Juergen Keil <jk at tools dot de>)
michaelni
parents:
766
diff
changeset
|
6289 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
|
6290 |
5404 | 6291 if(s->avctx->debug&FF_DEBUG_PICT_INFO) |
6292 show_pict_info(s); | |
6293 | |
0 | 6294 return 0; |
6295 } | |
144 | 6296 |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6297 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
|
6298 { |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6299 int format, width, height; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6300 |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6301 /* picture header */ |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6302 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
|
6303 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
|
6304 return -1; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6305 } |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6306 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
|
6307 if (format != 0 && format != 1) { |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
6308 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
|
6309 return -1; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6310 } |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6311 s->h263_flv = format+1; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6312 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
|
6313 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
|
6314 switch (format) { |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6315 case 0: |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6316 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
|
6317 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
|
6318 break; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6319 case 1: |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6320 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
|
6321 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
|
6322 break; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6323 case 2: |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6324 width = 352; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6325 height = 288; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6326 break; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6327 case 3: |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6328 width = 176; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6329 height = 144; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6330 break; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6331 case 4: |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6332 width = 128; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6333 height = 96; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6334 break; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6335 case 5: |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6336 width = 320; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6337 height = 240; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6338 break; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6339 case 6: |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6340 width = 160; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6341 height = 120; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6342 break; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6343 default: |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6344 width = height = 0; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6345 break; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6346 } |
2422 | 6347 if(avcodec_check_dimensions(s->avctx, width, height)) |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6348 return -1; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6349 s->width = width; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6350 s->height = height; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6351 |
6481 | 6352 s->pict_type = FF_I_TYPE + get_bits(&s->gb, 2); |
6353 s->dropable= s->pict_type > FF_P_TYPE; | |
1944 | 6354 if (s->dropable) |
6481 | 6355 s->pict_type = FF_P_TYPE; |
2967 | 6356 |
2979 | 6357 skip_bits1(&s->gb); /* deblocking flag */ |
1644 | 6358 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
|
6359 |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6360 s->h263_plus = 0; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6361 |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6362 s->unrestricted_mv = 1; |
1364 | 6363 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
|
6364 |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6365 /* PEI */ |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6366 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
|
6367 skip_bits(&s->gb, 8); |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6368 } |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6369 s->f_code = 1; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6370 |
1364 | 6371 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
|
6372 av_log(s->avctx, AV_LOG_DEBUG, "%c esc_type:%d, qp:%d num:%d\n", |
2414
18d77621fbc7
print "D" instead of "P" for dropable frames in flv with -debug 1
michael
parents:
2406
diff
changeset
|
6373 s->dropable ? 'D' : av_get_pict_type_char(s->pict_type), s->h263_flv-1, s->qscale, s->picture_number); |
1364 | 6374 } |
2967 | 6375 |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6376 s->y_dc_scale_table= |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6377 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
|
6378 |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6379 return 0; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6380 } |