Mercurial > libavcodec.hg
annotate h263.c @ 10726:1550e82f6183 libavcodec
cosmetics: Remove pointless '#if 1' preprocessor directives.
author | diego |
---|---|
date | Mon, 28 Dec 2009 15:27:49 +0000 |
parents | de2a496db0e5 |
children | 56e57dc0fe19 |
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 |
262 | 59 static int h263_decode_motion(MpegEncContext * s, int pred, int fcode); |
78 | 60 static int h263p_decode_umotion(MpegEncContext * s, int pred); |
0 | 61 static int h263_decode_block(MpegEncContext * s, DCTELEM * block, |
62 int n, int coded); | |
453 | 63 static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr); |
64 static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block, | |
1132 | 65 int n, int coded, int intra, int rvlc); |
8739
037e54d6c9c3
Remove pointless '#if CONFIG_ENCODERS' around forward declarations.
diego
parents:
8718
diff
changeset
|
66 |
1914 | 67 static void mpeg4_decode_sprite_trajectory(MpegEncContext * s, GetBitContext *gb); |
2003 | 68 static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, int level, int *dir_ptr, int encoding); |
1064 | 69 |
8590 | 70 #if CONFIG_ENCODERS |
10721
07c893df0334
cosmetics: Move a bunch of forward declarations below a CONFIG_ENCODERS #ifdef.
diego
parents:
10664
diff
changeset
|
71 static void h263_encode_block(MpegEncContext *s, DCTELEM *block, int n); |
07c893df0334
cosmetics: Move a bunch of forward declarations below a CONFIG_ENCODERS #ifdef.
diego
parents:
10664
diff
changeset
|
72 static void h263p_encode_umotion(MpegEncContext *s, int val); |
07c893df0334
cosmetics: Move a bunch of forward declarations below a CONFIG_ENCODERS #ifdef.
diego
parents:
10664
diff
changeset
|
73 static int h263_pred_dc(MpegEncContext *s, int n, int16_t **dc_val_ptr); |
07c893df0334
cosmetics: Move a bunch of forward declarations below a CONFIG_ENCODERS #ifdef.
diego
parents:
10664
diff
changeset
|
74 |
07c893df0334
cosmetics: Move a bunch of forward declarations below a CONFIG_ENCODERS #ifdef.
diego
parents:
10664
diff
changeset
|
75 static void mpeg4_encode_visual_object_header(MpegEncContext *s); |
07c893df0334
cosmetics: Move a bunch of forward declarations below a CONFIG_ENCODERS #ifdef.
diego
parents:
10664
diff
changeset
|
76 static void mpeg4_encode_vol_header(MpegEncContext *s, int vo_number, |
07c893df0334
cosmetics: Move a bunch of forward declarations below a CONFIG_ENCODERS #ifdef.
diego
parents:
10664
diff
changeset
|
77 int vol_number); |
07c893df0334
cosmetics: Move a bunch of forward declarations below a CONFIG_ENCODERS #ifdef.
diego
parents:
10664
diff
changeset
|
78 static inline void mpeg4_encode_block(MpegEncContext *s, DCTELEM *block, |
07c893df0334
cosmetics: Move a bunch of forward declarations below a CONFIG_ENCODERS #ifdef.
diego
parents:
10664
diff
changeset
|
79 int n, int dc, uint8_t *scan_table, |
07c893df0334
cosmetics: Move a bunch of forward declarations below a CONFIG_ENCODERS #ifdef.
diego
parents:
10664
diff
changeset
|
80 PutBitContext *dc_pb, |
07c893df0334
cosmetics: Move a bunch of forward declarations below a CONFIG_ENCODERS #ifdef.
diego
parents:
10664
diff
changeset
|
81 PutBitContext *ac_pb); |
07c893df0334
cosmetics: Move a bunch of forward declarations below a CONFIG_ENCODERS #ifdef.
diego
parents:
10664
diff
changeset
|
82 static int mpeg4_get_block_length(MpegEncContext *s, DCTELEM *block, int n, |
07c893df0334
cosmetics: Move a bunch of forward declarations below a CONFIG_ENCODERS #ifdef.
diego
parents:
10664
diff
changeset
|
83 int intra_dc, uint8_t *scan_table); |
07c893df0334
cosmetics: Move a bunch of forward declarations below a CONFIG_ENCODERS #ifdef.
diego
parents:
10664
diff
changeset
|
84 |
1064 | 85 static uint8_t uni_DCtab_lum_len[512]; |
86 static uint8_t uni_DCtab_chrom_len[512]; | |
87 static uint16_t uni_DCtab_lum_bits[512]; | |
88 static uint16_t uni_DCtab_chrom_bits[512]; | |
815
78accc54493b
put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents:
770
diff
changeset
|
89 |
4655 | 90 static uint8_t mv_penalty[MAX_FCODE+1][MAX_MV*2+1]; |
1064 | 91 static uint8_t fcode_tab[MAX_MV*2+1]; |
92 static uint8_t umv_fcode_tab[MAX_MV*2+1]; | |
815
78accc54493b
put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents:
770
diff
changeset
|
93 |
945 | 94 static uint32_t uni_mpeg4_intra_rl_bits[64*64*2*2]; |
95 static uint8_t uni_mpeg4_intra_rl_len [64*64*2*2]; | |
96 static uint32_t uni_mpeg4_inter_rl_bits[64*64*2*2]; | |
97 static uint8_t uni_mpeg4_inter_rl_len [64*64*2*2]; | |
2253 | 98 static uint8_t uni_h263_intra_aic_rl_len [64*64*2*2]; |
99 static uint8_t uni_h263_inter_rl_len [64*64*2*2]; | |
945 | 100 //#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
|
101 //#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run) + (level)*64) |
945 | 102 #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
|
103 |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream 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 /* 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
|
105 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
|
106 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
|
107 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
|
108 |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream 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 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
|
110 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
|
111 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
|
112 */ |
815
78accc54493b
put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents:
770
diff
changeset
|
113 #endif |
78accc54493b
put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents:
770
diff
changeset
|
114 |
4672 | 115 static uint8_t static_rl_table_store[5][2][2*MAX_RUN + MAX_LEVEL + 3]; |
116 | |
2646
c735e3e60ca7
Even More spelling errors. patch by (Kevin Baragona <kevinmb500 gawab com)
michael
parents:
2639
diff
changeset
|
117 #if 0 //3IV1 is quite rare and it slows things down a tiny bit |
8612 | 118 #define IS_3IV1 s->codec_tag == AV_RL32("3IV1") |
2967 | 119 #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
|
120 #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
|
121 #endif |
293 | 122 |
0 | 123 int h263_get_picture_format(int width, int height) |
124 { | |
125 int format; | |
126 | |
127 if (width == 128 && height == 96) | |
355 | 128 format = 1; |
0 | 129 else if (width == 176 && height == 144) |
355 | 130 format = 2; |
0 | 131 else if (width == 352 && height == 288) |
355 | 132 format = 3; |
0 | 133 else if (width == 704 && height == 576) |
355 | 134 format = 4; |
0 | 135 else if (width == 1408 && height == 1152) |
355 | 136 format = 5; |
0 | 137 else |
138 format = 7; | |
139 return format; | |
140 } | |
141 | |
5403 | 142 static void show_pict_info(MpegEncContext *s){ |
143 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", | |
144 s->qscale, av_get_pict_type_char(s->pict_type), | |
145 s->gb.size_in_bits, 1-s->no_rounding, | |
146 s->obmc ? " AP" : "", | |
147 s->umvplus ? " UMV" : "", | |
148 s->h263_long_vectors ? " LONG" : "", | |
149 s->h263_plus ? " +" : "", | |
150 s->h263_aic ? " AIC" : "", | |
151 s->alt_inter_vlc ? " AIV" : "", | |
152 s->modified_quant ? " MQ" : "", | |
153 s->loop_filter ? " LOOP" : "", | |
154 s->h263_slice_structured ? " SS" : "", | |
155 s->avctx->time_base.den, s->avctx->time_base.num | |
156 ); | |
157 } | |
158 | |
8590 | 159 #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
|
160 |
1548 | 161 static void aspect_to_info(MpegEncContext * s, AVRational aspect){ |
887 | 162 int i; |
163 | |
1548 | 164 if(aspect.num==0) aspect= (AVRational){1,1}; |
165 | |
887 | 166 for(i=1; i<6; i++){ |
1548 | 167 if(av_cmp_q(pixel_aspect[i], aspect) == 0){ |
887 | 168 s->aspect_ratio_info=i; |
169 return; | |
170 } | |
171 } | |
2967 | 172 |
887 | 173 s->aspect_ratio_info= FF_ASPECT_EXTENDED; |
880 | 174 } |
175 | |
1354 | 176 void ff_flv_encode_picture_header(MpegEncContext * s, int picture_number) |
0 | 177 { |
1354 | 178 int format; |
179 | |
180 align_put_bits(&s->pb); | |
181 | |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
182 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
|
183 put_bits(&s->pb, 5, (s->h263_flv-1)); /* 0: h263 escape codes 1: 11-bit escape codes */ |
2637 | 184 put_bits(&s->pb, 8, (((int64_t)s->picture_number * 30 * s->avctx->time_base.num) / //FIXME use timestamp |
185 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
|
186 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
|
187 format = 2; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
188 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
|
189 format = 3; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
190 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
|
191 format = 4; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
192 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
|
193 format = 5; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
194 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
|
195 format = 6; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
196 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
|
197 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
|
198 else |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
199 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
|
200 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
|
201 if (format == 0) { |
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->width); |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
203 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
|
204 } else if (format == 1) { |
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->width); |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
206 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
|
207 } |
6481 | 208 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
|
209 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
|
210 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
|
211 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
|
212 |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
213 if(s->h263_aic){ |
2967 | 214 s->y_dc_scale_table= |
1639 | 215 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
|
216 }else{ |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
217 s->y_dc_scale_table= |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
218 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
|
219 } |
1354 | 220 } |
221 | |
222 void h263_encode_picture_header(MpegEncContext * s, int picture_number) | |
223 { | |
1872 | 224 int format, coded_frame_rate, coded_frame_rate_base, i, temp_ref; |
225 int best_clock_code=1; | |
226 int best_divisor=60; | |
227 int best_error= INT_MAX; | |
2967 | 228 |
1872 | 229 if(s->h263_plus){ |
230 for(i=0; i<2; i++){ | |
231 int div, error; | |
2637 | 232 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
|
233 div= av_clip(div, 1, 127); |
4001 | 234 error= FFABS(s->avctx->time_base.num*1800000LL - (1000LL+i)*s->avctx->time_base.den*div); |
1872 | 235 if(error < best_error){ |
236 best_error= error; | |
237 best_divisor= div; | |
238 best_clock_code= i; | |
239 } | |
240 } | |
241 } | |
242 s->custom_pcf= best_clock_code!=1 || best_divisor!=60; | |
243 coded_frame_rate= 1800000; | |
244 coded_frame_rate_base= (1000+best_clock_code)*best_divisor; | |
1354 | 245 |
246 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
|
247 |
231 | 248 /* Update the pointer to last GOB */ |
9431 | 249 s->ptr_lastgob = put_bits_ptr(&s->pb); |
231 | 250 put_bits(&s->pb, 22, 0x20); /* PSC */ |
2637 | 251 temp_ref= s->picture_number * (int64_t)coded_frame_rate * s->avctx->time_base.num / //FIXME use timestamp |
252 (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
|
253 put_sbits(&s->pb, 8, temp_ref); /* TemporalReference */ |
0 | 254 |
2979 | 255 put_bits(&s->pb, 1, 1); /* marker */ |
256 put_bits(&s->pb, 1, 0); /* h263 id */ | |
257 put_bits(&s->pb, 1, 0); /* split screen off */ | |
258 put_bits(&s->pb, 1, 0); /* camera off */ | |
259 put_bits(&s->pb, 1, 0); /* freeze picture release off */ | |
2967 | 260 |
78 | 261 format = h263_get_picture_format(s->width, s->height); |
0 | 262 if (!s->h263_plus) { |
263 /* H.263v1 */ | |
264 put_bits(&s->pb, 3, format); | |
6481 | 265 put_bits(&s->pb, 1, (s->pict_type == FF_P_TYPE)); |
0 | 266 /* By now UMV IS DISABLED ON H.263v1, since the restrictions |
267 of H.263v1 UMV implies to check the predicted MV after | |
268 calculation of the current MB to see if we're on the limits */ | |
2979 | 269 put_bits(&s->pb, 1, 0); /* Unrestricted Motion Vector: off */ |
270 put_bits(&s->pb, 1, 0); /* SAC: off */ | |
271 put_bits(&s->pb, 1, s->obmc); /* Advanced Prediction */ | |
272 put_bits(&s->pb, 1, 0); /* only I/P frames, no PB frame */ | |
0 | 273 put_bits(&s->pb, 5, s->qscale); |
2979 | 274 put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */ |
0 | 275 } else { |
1872 | 276 int ufep=1; |
0 | 277 /* H.263v2 */ |
278 /* H.263 Plus PTYPE */ | |
2967 | 279 |
0 | 280 put_bits(&s->pb, 3, 7); |
1872 | 281 put_bits(&s->pb,3,ufep); /* Update Full Extended PTYPE */ |
78 | 282 if (format == 7) |
283 put_bits(&s->pb,3,6); /* Custom Source Format */ | |
284 else | |
285 put_bits(&s->pb, 3, format); | |
2967 | 286 |
1872 | 287 put_bits(&s->pb,1, s->custom_pcf); |
1661 | 288 put_bits(&s->pb,1, s->umvplus); /* Unrestricted Motion Vector */ |
0 | 289 put_bits(&s->pb,1,0); /* SAC: off */ |
1633 | 290 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
|
291 put_bits(&s->pb,1,s->h263_aic); /* Advanced Intra Coding */ |
1644 | 292 put_bits(&s->pb,1,s->loop_filter); /* Deblocking Filter */ |
1661 | 293 put_bits(&s->pb,1,s->h263_slice_structured); /* Slice Structured */ |
0 | 294 put_bits(&s->pb,1,0); /* Reference Picture Selection: off */ |
295 put_bits(&s->pb,1,0); /* Independent Segment Decoding: off */ | |
1637 | 296 put_bits(&s->pb,1,s->alt_inter_vlc); /* Alternative Inter VLC */ |
1644 | 297 put_bits(&s->pb,1,s->modified_quant); /* Modified Quantization: */ |
0 | 298 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */ |
299 put_bits(&s->pb,3,0); /* Reserved */ | |
2967 | 300 |
6481 | 301 put_bits(&s->pb, 3, s->pict_type == FF_P_TYPE); |
2967 | 302 |
0 | 303 put_bits(&s->pb,1,0); /* Reference Picture Resampling: off */ |
304 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
|
305 put_bits(&s->pb,1,s->no_rounding); /* Rounding Type */ |
0 | 306 put_bits(&s->pb,2,0); /* Reserved */ |
307 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */ | |
2967 | 308 |
0 | 309 /* This should be here if PLUSPTYPE */ |
2979 | 310 put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */ |
311 | |
312 if (format == 7) { | |
78 | 313 /* Custom Picture Format (CPFMT) */ |
1548 | 314 aspect_to_info(s, s->avctx->sample_aspect_ratio); |
880 | 315 |
316 put_bits(&s->pb,4,s->aspect_ratio_info); | |
78 | 317 put_bits(&s->pb,9,(s->width >> 2) - 1); |
318 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */ | |
319 put_bits(&s->pb,9,(s->height >> 2)); | |
1548 | 320 if (s->aspect_ratio_info == FF_ASPECT_EXTENDED){ |
321 put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.num); | |
322 put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.den); | |
2979 | 323 } |
78 | 324 } |
1872 | 325 if(s->custom_pcf){ |
326 if(ufep){ | |
327 put_bits(&s->pb, 1, best_clock_code); | |
328 put_bits(&s->pb, 7, best_divisor); | |
329 } | |
7260
3ec34b551aae
bitstream: move put_sbits() from flacenc.c to bitstream.h and use it
ramiro
parents:
7098
diff
changeset
|
330 put_sbits(&s->pb, 2, temp_ref>>8); |
1872 | 331 } |
2967 | 332 |
0 | 333 /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */ |
79
82e579c37bc3
Moved some H.263+ variables to MpegEncContext to be thread-safe.
pulento
parents:
78
diff
changeset
|
334 if (s->umvplus) |
1089 | 335 // put_bits(&s->pb,1,1); /* Limited according tables of Annex D */ |
1644 | 336 //FIXME check actual requested range |
1089 | 337 put_bits(&s->pb,2,1); /* unlimited */ |
1661 | 338 if(s->h263_slice_structured) |
339 put_bits(&s->pb,2,0); /* no weird submodes */ | |
1089 | 340 |
0 | 341 put_bits(&s->pb, 5, s->qscale); |
342 } | |
343 | |
2979 | 344 put_bits(&s->pb, 1, 0); /* no PEI */ |
498 | 345 |
1670 | 346 if(s->h263_slice_structured){ |
347 put_bits(&s->pb, 1, 1); | |
2967 | 348 |
1670 | 349 assert(s->mb_x == 0 && s->mb_y == 0); |
350 ff_h263_encode_mba(s); | |
351 | |
352 put_bits(&s->pb, 1, 1); | |
353 } | |
354 | |
498 | 355 if(s->h263_aic){ |
2967 | 356 s->y_dc_scale_table= |
1639 | 357 s->c_dc_scale_table= ff_aic_dc_scale_table; |
498 | 358 }else{ |
359 s->y_dc_scale_table= | |
360 s->c_dc_scale_table= ff_mpeg1_dc_scale_table; | |
361 } | |
0 | 362 } |
363 | |
766 | 364 /** |
365 * Encodes a group of blocks header. | |
366 */ | |
1661 | 367 void h263_encode_gob_header(MpegEncContext * s, int mb_line) |
162 | 368 { |
1661 | 369 put_bits(&s->pb, 17, 1); /* GBSC */ |
370 | |
371 if(s->h263_slice_structured){ | |
372 put_bits(&s->pb, 1, 1); | |
373 | |
374 ff_h263_encode_mba(s); | |
375 | |
376 if(s->mb_num > 1583) | |
377 put_bits(&s->pb, 1, 1); | |
378 put_bits(&s->pb, 5, s->qscale); /* GQUANT */ | |
379 put_bits(&s->pb, 1, 1); | |
6481 | 380 put_bits(&s->pb, 2, s->pict_type == FF_I_TYPE); /* GFID */ |
1661 | 381 }else{ |
382 int gob_number= mb_line / s->gob_index; | |
383 | |
384 put_bits(&s->pb, 5, gob_number); /* GN */ | |
6481 | 385 put_bits(&s->pb, 2, s->pict_type == FF_I_TYPE); /* GFID */ |
1661 | 386 put_bits(&s->pb, 5, s->qscale); /* GQUANT */ |
387 } | |
162 | 388 } |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
389 |
1492 | 390 static inline int get_block_rate(MpegEncContext * s, DCTELEM block[64], int block_last_index, uint8_t scantable[64]){ |
391 int last=0; | |
392 int j; | |
393 int rate=0; | |
394 | |
395 for(j=1; j<=block_last_index; j++){ | |
396 const int index= scantable[j]; | |
397 int level= block[index]; | |
398 if(level){ | |
399 level+= 64; | |
400 if((level&(~127)) == 0){ | |
401 if(j<block_last_index) rate+= s->intra_ac_vlc_length [UNI_AC_ENC_INDEX(j-last-1, level)]; | |
402 else rate+= s->intra_ac_vlc_last_length[UNI_AC_ENC_INDEX(j-last-1, level)]; | |
403 }else | |
404 rate += s->ac_esc_length; | |
405 | |
406 last= j; | |
407 } | |
408 } | |
2967 | 409 |
1492 | 410 return rate; |
411 } | |
412 | |
413 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
|
414 { |
1492 | 415 int score= 0; |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
416 int i, n; |
903 | 417 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
|
418 |
1492 | 419 memcpy(zigzag_last_index, s->block_last_index, sizeof(int)*6); |
2967 | 420 |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
421 for(n=0; n<6; n++){ |
1064 | 422 int16_t *ac_val, *ac_val1; |
2967 | 423 |
1492 | 424 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
|
425 |
266 | 426 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
|
427 ac_val1= ac_val; |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
428 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
|
429 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
|
430 /* top prediction */ |
266 | 431 ac_val-= s->block_wrap[n]*16; |
903 | 432 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
|
433 /* same qscale */ |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
434 for(i=1; i<8; i++){ |
1092 | 435 const int level= block[n][s->dsp.idct_permutation[i ]]; |
1492 | 436 block[n][s->dsp.idct_permutation[i ]] = level - ac_val[i+8]; |
1092 | 437 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
|
438 ac_val1[i+8]= level; |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
439 } |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
440 }else{ |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
441 /* different qscale, we must rescale */ |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
442 for(i=1; i<8; i++){ |
1092 | 443 const int level= block[n][s->dsp.idct_permutation[i ]]; |
1492 | 444 block[n][s->dsp.idct_permutation[i ]] = level - ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale); |
1092 | 445 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
|
446 ac_val1[i+8]= level; |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
447 } |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
448 } |
1492 | 449 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
|
450 }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
|
451 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
|
452 /* left prediction */ |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
453 ac_val-= 16; |
903 | 454 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
|
455 /* same qscale */ |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
456 for(i=1; i<8; i++){ |
1092 | 457 const int level= block[n][s->dsp.idct_permutation[i<<3]]; |
1492 | 458 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
|
459 ac_val1[i ]= level; |
1092 | 460 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
|
461 } |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
462 }else{ |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
463 /* different qscale, we must rescale */ |
852b5a416161
fixing ac prediction encoding with adaptive quantization
michaelni
parents:
690
diff
changeset
|
464 for(i=1; i<8; i++){ |
1092 | 465 const int level= block[n][s->dsp.idct_permutation[i<<3]]; |
1492 | 466 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
|
467 ac_val1[i ]= level; |
1092 | 468 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
|
469 } |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
470 } |
1492 | 471 st[n]= s->intra_v_scantable.permutated; |
472 } | |
473 | |
474 for(i=63; i>0; i--) //FIXME optimize | |
475 if(block[n][ st[n][i] ]) break; | |
476 s->block_last_index[n]= i; | |
477 | |
478 score += get_block_rate(s, block[n], s->block_last_index[n], st[n]); | |
479 } | |
480 | |
481 return score < 0; | |
482 } | |
483 | |
484 static inline void restore_ac_coeffs(MpegEncContext * s, DCTELEM block[6][64], int dir[6], uint8_t *st[6], int zigzag_last_index[6]) | |
485 { | |
486 int i, n; | |
487 memcpy(s->block_last_index, zigzag_last_index, sizeof(int)*6); | |
488 | |
489 for(n=0; n<6; n++){ | |
490 int16_t *ac_val = s->ac_val[0][0] + s->block_index[n] * 16; | |
491 | |
492 st[n]= s->intra_scantable.permutated; | |
493 if(dir[n]){ | |
494 /* top prediction */ | |
495 for(i=1; i<8; i++){ | |
496 block[n][s->dsp.idct_permutation[i ]] = ac_val[i+8]; | |
497 } | |
498 }else{ | |
499 /* left prediction */ | |
500 for(i=1; i<8; i++){ | |
501 block[n][s->dsp.idct_permutation[i<<3]]= ac_val[i ]; | |
502 } | |
265
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 } |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
506 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
507 /** |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
508 * 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
|
509 */ |
695 | 510 void ff_clean_h263_qscales(MpegEncContext *s){ |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
511 int i; |
903 | 512 int8_t * const qscale_table= s->current_picture.qscale_table; |
2967 | 513 |
4316 | 514 ff_init_qscale_tab(s); |
515 | |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
516 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
|
517 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
|
518 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
|
519 } |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
520 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
|
521 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
|
522 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
|
523 } |
1983 | 524 |
525 if(s->codec_id != CODEC_ID_H263P){ | |
526 for(i=1; i<s->mb_num; i++){ | |
527 int mb_xy= s->mb_index2xy[i]; | |
2967 | 528 |
1983 | 529 if(qscale_table[mb_xy] != qscale_table[s->mb_index2xy[i-1]] && (s->mb_type[mb_xy]&CANDIDATE_MB_TYPE_INTER4V)){ |
530 s->mb_type[mb_xy]|= CANDIDATE_MB_TYPE_INTER; | |
531 } | |
532 } | |
533 } | |
695 | 534 } |
535 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
536 /** |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
537 * 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
|
538 */ |
695 | 539 void ff_clean_mpeg4_qscales(MpegEncContext *s){ |
540 int i; | |
903 | 541 int8_t * const qscale_table= s->current_picture.qscale_table; |
542 | |
695 | 543 ff_clean_h263_qscales(s); |
2967 | 544 |
6481 | 545 if(s->pict_type== FF_B_TYPE){ |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
546 int odd=0; |
2646
c735e3e60ca7
Even More spelling errors. patch by (Kevin Baragona <kevinmb500 gawab com)
michael
parents:
2639
diff
changeset
|
547 /* ok, come on, this isn't funny anymore, there's more code for handling this mpeg4 mess than for the actual adaptive quantization */ |
2967 | 548 |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
549 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
|
550 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
|
551 odd += qscale_table[mb_xy]&1; |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
552 } |
2967 | 553 |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
554 if(2*odd > s->mb_num) odd=1; |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
555 else odd=0; |
2967 | 556 |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
557 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
|
558 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
|
559 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
|
560 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
|
561 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
|
562 qscale_table[mb_xy]= 31; |
2967 | 563 } |
564 | |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
565 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
|
566 int mb_xy= s->mb_index2xy[i]; |
1708 | 567 if(qscale_table[mb_xy] != qscale_table[s->mb_index2xy[i-1]] && (s->mb_type[mb_xy]&CANDIDATE_MB_TYPE_DIRECT)){ |
568 s->mb_type[mb_xy]|= CANDIDATE_MB_TYPE_BIDIR; | |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
569 } |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
570 } |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
571 } |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
572 } |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
573 |
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
|
574 #endif //CONFIG_ENCODERS |
3247 | 575 |
8042 | 576 #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
|
577 #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
|
578 |
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
|
579 void ff_mpeg4_init_direct_mv(MpegEncContext *s){ |
3247 | 580 int i; |
581 for(i=0; i<tab_size; i++){ | |
582 s->direct_scale_mv[0][i] = (i-tab_bias)*s->pb_time/s->pp_time; | |
583 s->direct_scale_mv[1][i] = (i-tab_bias)*(s->pb_time-s->pp_time)/s->pp_time; | |
584 } | |
585 } | |
586 | |
587 static inline void ff_mpeg4_set_one_direct_mv(MpegEncContext *s, int mx, int my, int i){ | |
588 int xy= s->block_index[i]; | |
589 uint16_t time_pp= s->pp_time; | |
590 uint16_t time_pb= s->pb_time; | |
591 int p_mx, p_my; | |
592 | |
593 p_mx= s->next_picture.motion_val[0][xy][0]; | |
594 if((unsigned)(p_mx + tab_bias) < tab_size){ | |
595 s->mv[0][i][0] = s->direct_scale_mv[0][p_mx + tab_bias] + mx; | |
596 s->mv[1][i][0] = mx ? s->mv[0][i][0] - p_mx | |
597 : s->direct_scale_mv[1][p_mx + tab_bias]; | |
598 }else{ | |
599 s->mv[0][i][0] = p_mx*time_pb/time_pp + mx; | |
600 s->mv[1][i][0] = mx ? s->mv[0][i][0] - p_mx | |
601 : p_mx*(time_pb - time_pp)/time_pp; | |
602 } | |
603 p_my= s->next_picture.motion_val[0][xy][1]; | |
604 if((unsigned)(p_my + tab_bias) < tab_size){ | |
605 s->mv[0][i][1] = s->direct_scale_mv[0][p_my + tab_bias] + my; | |
606 s->mv[1][i][1] = my ? s->mv[0][i][1] - p_my | |
607 : s->direct_scale_mv[1][p_my + tab_bias]; | |
608 }else{ | |
609 s->mv[0][i][1] = p_my*time_pb/time_pp + my; | |
610 s->mv[1][i][1] = my ? s->mv[0][i][1] - p_my | |
611 : p_my*(time_pb - time_pp)/time_pp; | |
612 } | |
613 } | |
614 | |
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
|
615 #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
|
616 #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
|
617 |
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
|
618 /** |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
619 * |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
620 * @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
|
621 */ |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
622 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
|
623 const int mb_index= s->mb_x + s->mb_y*s->mb_stride; |
1708 | 624 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
|
625 uint16_t time_pp; |
fb240cb99bcf
Remove useless init from ff_mpeg4_set_direct_mv() found by CSA.
michael
parents:
9481
diff
changeset
|
626 uint16_t time_pb; |
936 | 627 int i; |
2967 | 628 |
936 | 629 //FIXME avoid divides |
3247 | 630 // try special case with shifts for 1 and 3 B-frames? |
2967 | 631 |
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
|
632 if(IS_8X8(colocated_mb_type)){ |
936 | 633 s->mv_type = MV_TYPE_8X8; |
634 for(i=0; i<4; i++){ | |
3247 | 635 ff_mpeg4_set_one_direct_mv(s, mx, my, i); |
936 | 636 } |
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
|
637 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
|
638 } else if(IS_INTERLACED(colocated_mb_type)){ |
936 | 639 s->mv_type = MV_TYPE_FIELD; |
640 for(i=0; i<2; i++){ | |
1948 | 641 int field_select= s->next_picture.ref_index[0][s->block_index[2*i]]; |
3205 | 642 s->field_select[0][i]= field_select; |
643 s->field_select[1][i]= i; | |
936 | 644 if(s->top_field_first){ |
1948 | 645 time_pp= s->pp_field_time - field_select + i; |
646 time_pb= s->pb_field_time - field_select + i; | |
936 | 647 }else{ |
1948 | 648 time_pp= s->pp_field_time + field_select - i; |
649 time_pb= s->pb_field_time + field_select - i; | |
936 | 650 } |
1708 | 651 s->mv[0][i][0] = s->p_field_mv_table[i][0][mb_index][0]*time_pb/time_pp + mx; |
652 s->mv[0][i][1] = s->p_field_mv_table[i][0][mb_index][1]*time_pb/time_pp + my; | |
653 s->mv[1][i][0] = mx ? s->mv[0][i][0] - s->p_field_mv_table[i][0][mb_index][0] | |
654 : s->p_field_mv_table[i][0][mb_index][0]*(time_pb - time_pp)/time_pp; | |
2967 | 655 s->mv[1][i][1] = my ? s->mv[0][i][1] - s->p_field_mv_table[i][0][mb_index][1] |
1708 | 656 : s->p_field_mv_table[i][0][mb_index][1]*(time_pb - time_pp)/time_pp; |
936 | 657 } |
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
|
658 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
|
659 }else{ |
3247 | 660 ff_mpeg4_set_one_direct_mv(s, mx, my, 0); |
661 s->mv[0][1][0] = s->mv[0][2][0] = s->mv[0][3][0] = s->mv[0][0][0]; | |
662 s->mv[0][1][1] = s->mv[0][2][1] = s->mv[0][3][1] = s->mv[0][0][1]; | |
663 s->mv[1][1][0] = s->mv[1][2][0] = s->mv[1][3][0] = s->mv[1][0][0]; | |
664 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
|
665 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
|
666 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
|
667 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
|
668 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
|
669 return MB_TYPE_DIRECT2 | MB_TYPE_16x16 | MB_TYPE_L0L1; //Note see prev line |
936 | 670 } |
671 } | |
672 | |
1389 | 673 void ff_h263_update_motion_val(MpegEncContext * s){ |
674 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
|
675 //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
|
676 const int wrap = s->b8_stride; |
1389 | 677 const int xy = s->block_index[0]; |
2967 | 678 |
679 s->current_picture.mbskip_table[mb_xy]= s->mb_skipped; | |
1389 | 680 |
681 if(s->mv_type != MV_TYPE_8X8){ | |
682 int motion_x, motion_y; | |
683 if (s->mb_intra) { | |
684 motion_x = 0; | |
685 motion_y = 0; | |
686 } else if (s->mv_type == MV_TYPE_16X16) { | |
687 motion_x = s->mv[0][0][0]; | |
688 motion_y = s->mv[0][0][1]; | |
689 } else /*if (s->mv_type == MV_TYPE_FIELD)*/ { | |
690 int i; | |
691 motion_x = s->mv[0][0][0] + s->mv[0][1][0]; | |
692 motion_y = s->mv[0][0][1] + s->mv[0][1][1]; | |
693 motion_x = (motion_x>>1) | (motion_x&1); | |
694 for(i=0; i<2; i++){ | |
1708 | 695 s->p_field_mv_table[i][0][mb_xy][0]= s->mv[0][i][0]; |
696 s->p_field_mv_table[i][0][mb_xy][1]= s->mv[0][i][1]; | |
1389 | 697 } |
1948 | 698 s->current_picture.ref_index[0][xy ]= |
699 s->current_picture.ref_index[0][xy + 1]= s->field_select[0][0]; | |
700 s->current_picture.ref_index[0][xy + wrap ]= | |
701 s->current_picture.ref_index[0][xy + wrap + 1]= s->field_select[0][1]; | |
1389 | 702 } |
1948 | 703 |
1389 | 704 /* 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
|
705 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
|
706 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
|
707 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
|
708 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
|
709 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
|
710 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
|
711 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
|
712 s->current_picture.motion_val[0][xy + 1 + wrap][1] = motion_y; |
1389 | 713 } |
714 | |
715 if(s->encoding){ //FIXME encoding MUST be cleaned up | |
2967 | 716 if (s->mv_type == MV_TYPE_8X8) |
1389 | 717 s->current_picture.mb_type[mb_xy]= MB_TYPE_L0 | MB_TYPE_8x8; |
1633 | 718 else if(s->mb_intra) |
719 s->current_picture.mb_type[mb_xy]= MB_TYPE_INTRA; | |
1389 | 720 else |
721 s->current_picture.mb_type[mb_xy]= MB_TYPE_L0 | MB_TYPE_16x16; | |
722 } | |
723 } | |
724 | |
8590 | 725 #if CONFIG_ENCODERS |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
726 |
2502 | 727 static inline int h263_get_motion_length(MpegEncContext * s, int val, int f_code){ |
728 int l, bit_size, code; | |
729 | |
730 if (val == 0) { | |
731 return mvtab[0][1]; | |
732 } else { | |
733 bit_size = f_code - 1; | |
734 /* modulo encoding */ | |
735 l= INT_BIT - 6 - bit_size; | |
736 val = (val<<l)>>l; | |
737 val--; | |
738 code = (val >> bit_size) + 1; | |
739 | |
740 return mvtab[code][1] + 1 + bit_size; | |
741 } | |
742 } | |
743 | |
744 static inline void ff_h263_encode_motion_vector(MpegEncContext * s, int x, int y, int f_code){ | |
745 if(s->flags2 & CODEC_FLAG2_NO_OUTPUT){ | |
2967 | 746 skip_put_bits(&s->pb, |
2502 | 747 h263_get_motion_length(s, x, f_code) |
748 +h263_get_motion_length(s, y, f_code)); | |
749 }else{ | |
750 ff_h263_encode_motion(s, x, f_code); | |
751 ff_h263_encode_motion(s, y, f_code); | |
752 } | |
753 } | |
754 | |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
755 static inline int get_p_cbp(MpegEncContext * s, |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
756 DCTELEM block[6][64], |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
757 int motion_x, int motion_y){ |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
758 int cbp, i; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
759 |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
760 if(s->flags & CODEC_FLAG_CBP_RD){ |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
761 int best_cbpy_score= INT_MAX; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
762 int best_cbpc_score= INT_MAX; |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
763 int cbpc = (-1), cbpy= (-1); |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
764 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
|
765 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
|
766 |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
767 for(i=0; i<4; i++){ |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
768 int score= inter_MCBPC_bits[i + offset] * lambda; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
769 if(i&1) score += s->coded_score[5]; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
770 if(i&2) score += s->coded_score[4]; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
771 |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
772 if(score < best_cbpc_score){ |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
773 best_cbpc_score= score; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
774 cbpc= i; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
775 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
776 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
777 |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
778 for(i=0; i<16; i++){ |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
779 int score= cbpy_tab[i ^ 0xF][1] * lambda; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
780 if(i&1) score += s->coded_score[3]; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
781 if(i&2) score += s->coded_score[2]; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
782 if(i&4) score += s->coded_score[1]; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
783 if(i&8) score += s->coded_score[0]; |
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_cbpy_score){ |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
786 best_cbpy_score= score; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
787 cbpy= 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 cbp= cbpc + 4*cbpy; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
791 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
|
792 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
|
793 cbp= 0; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
794 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
795 |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
796 for (i = 0; i < 6; i++) { |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
797 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
|
798 s->block_last_index[i]= -1; |
8288 | 799 s->dsp.clear_block(s->block[i]); |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
800 } |
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 }else{ |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
803 cbp= 0; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
804 for (i = 0; i < 6; i++) { |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
805 if (s->block_last_index[i] >= 0) |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
806 cbp |= 1 << (5 - i); |
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 return cbp; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
810 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
811 |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
812 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
|
813 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
|
814 int cbp=0, i; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
815 |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
816 if(s->flags & CODEC_FLAG_CBP_RD){ |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
817 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
|
818 const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6); |
2967 | 819 |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
820 for(i=0; i<6; i++){ |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
821 if(s->coded_score[i] < 0){ |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
822 score += s->coded_score[i]; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
823 cbp |= 1 << (5 - i); |
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 } |
2967 | 826 |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
827 if(cbp){ |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
828 int zero_score= -6; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
829 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
|
830 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
|
831 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
832 |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
833 zero_score*= lambda; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
834 if(zero_score <= score){ |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
835 cbp=0; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
836 } |
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 |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
839 for (i = 0; i < 6; i++) { |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
840 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
|
841 s->block_last_index[i]= -1; |
8288 | 842 s->dsp.clear_block(s->block[i]); |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
843 } |
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 }else{ |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
846 for (i = 0; i < 6; i++) { |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
847 if (s->block_last_index[i] >= 0) |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
848 cbp |= 1 << (5 - i); |
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 return cbp; |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
852 } |
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
853 |
2967 | 854 static inline void mpeg4_encode_blocks(MpegEncContext * s, DCTELEM block[6][64], int intra_dc[6], |
2502 | 855 uint8_t **scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb){ |
856 int i; | |
2967 | 857 |
2502 | 858 if(scan_table){ |
859 if(s->flags2 & CODEC_FLAG2_NO_OUTPUT){ | |
860 for (i = 0; i < 6; i++) { | |
861 skip_put_bits(&s->pb, mpeg4_get_block_length(s, block[i], i, intra_dc[i], scan_table[i])); | |
862 } | |
863 }else{ | |
864 /* encode each block */ | |
865 for (i = 0; i < 6; i++) { | |
866 mpeg4_encode_block(s, block[i], i, intra_dc[i], scan_table[i], dc_pb, ac_pb); | |
867 } | |
868 } | |
869 }else{ | |
870 if(s->flags2 & CODEC_FLAG2_NO_OUTPUT){ | |
871 for (i = 0; i < 6; i++) { | |
872 skip_put_bits(&s->pb, mpeg4_get_block_length(s, block[i], i, 0, s->intra_scantable.permutated)); | |
873 } | |
874 }else{ | |
875 /* encode each block */ | |
876 for (i = 0; i < 6; i++) { | |
877 mpeg4_encode_block(s, block[i], i, 0, s->intra_scantable.permutated, dc_pb, ac_pb); | |
878 } | |
879 } | |
880 } | |
881 } | |
882 | |
8644 | 883 static const int dquant_code[5]= {1,0,9,2,3}; |
884 | |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
885 void mpeg4_encode_mb(MpegEncContext * s, |
2979 | 886 DCTELEM block[6][64], |
887 int motion_x, int motion_y) | |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
888 { |
1057 | 889 int cbpc, cbpy, pred_x, pred_y; |
453 | 890 PutBitContext * const pb2 = s->data_partitioning ? &s->pb2 : &s->pb; |
6481 | 891 PutBitContext * const tex_pb = s->data_partitioning && s->pict_type!=FF_B_TYPE ? &s->tex_pb : &s->pb; |
892 PutBitContext * const dc_pb = s->data_partitioning && s->pict_type!=FF_I_TYPE ? &s->pb2 : &s->pb; | |
453 | 893 const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1) && !s->data_partitioning ? 1 : 0; |
2967 | 894 |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
895 if (!s->mb_intra) { |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
896 int i, cbp; |
2967 | 897 |
6481 | 898 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
|
899 static const int mb_type_table[8]= {-1, 3, 2, 1,-1,-1,-1, 0}; /* convert from mv_dir to type */ |
324 | 900 int mb_type= mb_type_table[s->mv_dir]; |
1708 | 901 |
324 | 902 if(s->mb_x==0){ |
1708 | 903 for(i=0; i<2; i++){ |
2967 | 904 s->last_mv[i][0][0]= |
905 s->last_mv[i][0][1]= | |
906 s->last_mv[i][1][0]= | |
1708 | 907 s->last_mv[i][1][1]= 0; |
908 } | |
324 | 909 } |
2967 | 910 |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
911 assert(s->dquant>=-2 && s->dquant<=2); |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
912 assert((s->dquant&1)==0); |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
913 assert(mb_type>=0); |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
914 |
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
|
915 /* 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
|
916 if(s->next_picture.mbskip_table[s->mb_y * s->mb_stride + s->mb_x]){ //FIXME avoid DCT & ... |
324 | 917 s->skip_count++; |
2967 | 918 s->mv[0][0][0]= |
919 s->mv[0][0][1]= | |
920 s->mv[1][0][0]= | |
324 | 921 s->mv[1][0][1]= 0; |
2646
c735e3e60ca7
Even More spelling errors. patch by (Kevin Baragona <kevinmb500 gawab com)
michael
parents:
2639
diff
changeset
|
922 s->mv_dir= MV_DIR_FORWARD; //doesn't matter |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
923 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
|
924 // s->mb_skipped=1; |
903 | 925 |
324 | 926 return; |
927 } | |
2967 | 928 |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
929 cbp= get_b_cbp(s, block, motion_x, motion_y, mb_type); |
2967 | 930 |
324 | 931 if ((cbp | motion_x | motion_y | mb_type) ==0) { |
932 /* direct MB with MV={0,0} */ | |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
933 assert(s->dquant==0); |
2967 | 934 |
324 | 935 put_bits(&s->pb, 1, 1); /* mb not coded modb1=1 */ |
453 | 936 |
937 if(interleaved_stats){ | |
938 s->misc_bits++; | |
939 s->last_bits++; | |
940 } | |
324 | 941 s->skip_count++; |
942 return; | |
943 } | |
2967 | 944 |
2979 | 945 put_bits(&s->pb, 1, 0); /* mb coded modb1=0 */ |
324 | 946 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
|
947 put_bits(&s->pb, mb_type+1, 1); // this table is so simple that we don't need it :) |
324 | 948 if(cbp) put_bits(&s->pb, 6, cbp); |
2967 | 949 |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
950 if(cbp && mb_type){ |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
951 if(s->dquant) |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
952 put_bits(&s->pb, 2, (s->dquant>>2)+3); |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
953 else |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
954 put_bits(&s->pb, 1, 0); |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
955 }else |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
956 s->qscale -= s->dquant; |
2967 | 957 |
697 | 958 if(!s->progressive_sequence){ |
959 if(cbp) | |
960 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
|
961 if(mb_type) // not direct mode |
1708 | 962 put_bits(&s->pb, 1, s->mv_type == MV_TYPE_FIELD); |
697 | 963 } |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
964 |
453 | 965 if(interleaved_stats){ |
1164 | 966 s->misc_bits+= get_bits_diff(s); |
453 | 967 } |
295 | 968 |
1708 | 969 if(mb_type == 0){ |
970 assert(s->mv_dir & MV_DIRECT); | |
2502 | 971 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
|
972 s->b_count++; |
e47fa3e3f2d5
statistics for forw & back p-MBs instead of just one counter for both
michaelni
parents:
654
diff
changeset
|
973 s->f_count++; |
1708 | 974 }else{ |
975 assert(mb_type > 0 && mb_type < 4); | |
976 if(s->mv_type != MV_TYPE_FIELD){ | |
977 if(s->mv_dir & MV_DIR_FORWARD){ | |
2502 | 978 ff_h263_encode_motion_vector(s, s->mv[0][0][0] - s->last_mv[0][0][0], |
979 s->mv[0][0][1] - s->last_mv[0][0][1], s->f_code); | |
1708 | 980 s->last_mv[0][0][0]= s->last_mv[0][1][0]= s->mv[0][0][0]; |
981 s->last_mv[0][0][1]= s->last_mv[0][1][1]= s->mv[0][0][1]; | |
982 s->f_count++; | |
983 } | |
984 if(s->mv_dir & MV_DIR_BACKWARD){ | |
2502 | 985 ff_h263_encode_motion_vector(s, s->mv[1][0][0] - s->last_mv[1][0][0], |
986 s->mv[1][0][1] - s->last_mv[1][0][1], s->b_code); | |
1708 | 987 s->last_mv[1][0][0]= s->last_mv[1][1][0]= s->mv[1][0][0]; |
988 s->last_mv[1][0][1]= s->last_mv[1][1][1]= s->mv[1][0][1]; | |
989 s->b_count++; | |
990 } | |
991 }else{ | |
992 if(s->mv_dir & MV_DIR_FORWARD){ | |
993 put_bits(&s->pb, 1, s->field_select[0][0]); | |
994 put_bits(&s->pb, 1, s->field_select[0][1]); | |
995 } | |
996 if(s->mv_dir & MV_DIR_BACKWARD){ | |
997 put_bits(&s->pb, 1, s->field_select[1][0]); | |
998 put_bits(&s->pb, 1, s->field_select[1][1]); | |
999 } | |
1000 if(s->mv_dir & MV_DIR_FORWARD){ | |
1001 for(i=0; i<2; i++){ | |
2502 | 1002 ff_h263_encode_motion_vector(s, s->mv[0][i][0] - s->last_mv[0][i][0] , |
1003 s->mv[0][i][1] - s->last_mv[0][i][1]/2, s->f_code); | |
1708 | 1004 s->last_mv[0][i][0]= s->mv[0][i][0]; |
1005 s->last_mv[0][i][1]= s->mv[0][i][1]*2; | |
1006 } | |
1007 s->f_count++; | |
1008 } | |
1009 if(s->mv_dir & MV_DIR_BACKWARD){ | |
1010 for(i=0; i<2; i++){ | |
2502 | 1011 ff_h263_encode_motion_vector(s, s->mv[1][i][0] - s->last_mv[1][i][0] , |
1012 s->mv[1][i][1] - s->last_mv[1][i][1]/2, s->b_code); | |
1708 | 1013 s->last_mv[1][i][0]= s->mv[1][i][0]; |
1014 s->last_mv[1][i][1]= s->mv[1][i][1]*2; | |
1015 } | |
1016 s->b_count++; | |
1017 } | |
1018 } | |
324 | 1019 } |
453 | 1020 |
1021 if(interleaved_stats){ | |
1164 | 1022 s->mv_bits+= get_bits_diff(s); |
453 | 1023 } |
295 | 1024 |
2502 | 1025 mpeg4_encode_blocks(s, block, NULL, NULL, NULL, &s->pb); |
453 | 1026 |
1027 if(interleaved_stats){ | |
1164 | 1028 s->p_tex_bits+= get_bits_diff(s); |
453 | 1029 } |
1708 | 1030 |
6481 | 1031 }else{ /* s->pict_type==FF_B_TYPE */ |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
1032 cbp= get_p_cbp(s, block, motion_x, motion_y); |
2967 | 1033 |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
1034 if ((cbp | motion_x | motion_y | s->dquant) == 0 && s->mv_type==MV_TYPE_16X16) { |
2967 | 1035 /* 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
|
1036 why didn't they just compress the skip-mb bits instead of reusing them ?! */ |
331 | 1037 if(s->max_b_frames>0){ |
1038 int i; | |
364
6b6332e7008a
segfault fix for b-frame encoding with height%16!=0
michaelni
parents:
360
diff
changeset
|
1039 int x,y, offset; |
6b6332e7008a
segfault fix for b-frame encoding with height%16!=0
michaelni
parents:
360
diff
changeset
|
1040 uint8_t *p_pic; |
6b6332e7008a
segfault fix for b-frame encoding with height%16!=0
michaelni
parents:
360
diff
changeset
|
1041 |
6b6332e7008a
segfault fix for b-frame encoding with height%16!=0
michaelni
parents:
360
diff
changeset
|
1042 x= s->mb_x*16; |
6b6332e7008a
segfault fix for b-frame encoding with height%16!=0
michaelni
parents:
360
diff
changeset
|
1043 y= s->mb_y*16; |
6b6332e7008a
segfault fix for b-frame encoding with height%16!=0
michaelni
parents:
360
diff
changeset
|
1044 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
|
1045 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
|
1046 |
6b6332e7008a
segfault fix for b-frame encoding with height%16!=0
michaelni
parents:
360
diff
changeset
|
1047 offset= x + y*s->linesize; |
903 | 1048 p_pic= s->new_picture.data[0] + offset; |
2967 | 1049 |
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
|
1050 s->mb_skipped=1; |
331 | 1051 for(i=0; i<s->max_b_frames; i++){ |
339 | 1052 uint8_t *b_pic; |
1053 int diff; | |
903 | 1054 Picture *pic= s->reordered_input_picture[i+1]; |
1055 | |
6481 | 1056 if(pic==NULL || pic->pict_type!=FF_B_TYPE) break; |
903 | 1057 |
3068 | 1058 b_pic= pic->data[0] + offset; |
1059 if(pic->type != FF_BUFFER_TYPE_SHARED) | |
1060 b_pic+= INPLACE_OFFSET; | |
2979 | 1061 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
|
1062 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
|
1063 s->mb_skipped=0; |
331 | 1064 break; |
1065 } | |
1066 } | |
1067 }else | |
2967 | 1068 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
|
1069 |
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
|
1070 if(s->mb_skipped==1){ |
331 | 1071 /* skip macroblock */ |
1072 put_bits(&s->pb, 1, 1); | |
453 | 1073 |
1074 if(interleaved_stats){ | |
1075 s->misc_bits++; | |
1076 s->last_bits++; | |
1077 } | |
331 | 1078 s->skip_count++; |
2967 | 1079 |
331 | 1080 return; |
1081 } | |
295 | 1082 } |
364
6b6332e7008a
segfault fix for b-frame encoding with height%16!=0
michaelni
parents:
360
diff
changeset
|
1083 |
2979 | 1084 put_bits(&s->pb, 1, 0); /* mb coded */ |
1633 | 1085 cbpc = cbp & 3; |
1086 cbpy = cbp >> 2; | |
1087 cbpy ^= 0xf; | |
324 | 1088 if(s->mv_type==MV_TYPE_16X16){ |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
1089 if(s->dquant) cbpc+= 8; |
324 | 1090 put_bits(&s->pb, |
1091 inter_MCBPC_bits[cbpc], | |
1092 inter_MCBPC_code[cbpc]); | |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
1093 |
453 | 1094 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
|
1095 if(s->dquant) |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
1096 put_bits(pb2, 2, dquant_code[s->dquant+2]); |
697 | 1097 |
1098 if(!s->progressive_sequence){ | |
1099 if(cbp) | |
1100 put_bits(pb2, 1, s->interlaced_dct); | |
1708 | 1101 put_bits(pb2, 1, 0); |
697 | 1102 } |
2967 | 1103 |
453 | 1104 if(interleaved_stats){ |
1164 | 1105 s->misc_bits+= get_bits_diff(s); |
453 | 1106 } |
324 | 1107 |
1108 /* motion vectors: 16x16 mode */ | |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
1109 h263_pred_motion(s, 0, 0, &pred_x, &pred_y); |
2967 | 1110 |
2502 | 1111 ff_h263_encode_motion_vector(s, motion_x - pred_x, |
1112 motion_y - pred_y, s->f_code); | |
1708 | 1113 }else if(s->mv_type==MV_TYPE_FIELD){ |
1114 if(s->dquant) cbpc+= 8; | |
1115 put_bits(&s->pb, | |
1116 inter_MCBPC_bits[cbpc], | |
1117 inter_MCBPC_code[cbpc]); | |
1118 | |
1119 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]); | |
1120 if(s->dquant) | |
1121 put_bits(pb2, 2, dquant_code[s->dquant+2]); | |
1122 | |
1123 assert(!s->progressive_sequence); | |
1124 if(cbp) | |
1125 put_bits(pb2, 1, s->interlaced_dct); | |
1126 put_bits(pb2, 1, 1); | |
2967 | 1127 |
1708 | 1128 if(interleaved_stats){ |
1129 s->misc_bits+= get_bits_diff(s); | |
1130 } | |
1131 | |
1132 /* motion vectors: 16x8 interlaced mode */ | |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
1133 h263_pred_motion(s, 0, 0, &pred_x, &pred_y); |
1708 | 1134 pred_y /=2; |
2967 | 1135 |
1708 | 1136 put_bits(&s->pb, 1, s->field_select[0][0]); |
1137 put_bits(&s->pb, 1, s->field_select[0][1]); | |
2967 | 1138 |
2502 | 1139 ff_h263_encode_motion_vector(s, s->mv[0][0][0] - pred_x, |
1140 s->mv[0][0][1] - pred_y, s->f_code); | |
1141 ff_h263_encode_motion_vector(s, s->mv[0][1][0] - pred_x, | |
1142 s->mv[0][1][1] - pred_y, s->f_code); | |
324 | 1143 }else{ |
1708 | 1144 assert(s->mv_type==MV_TYPE_8X8); |
324 | 1145 put_bits(&s->pb, |
1633 | 1146 inter_MCBPC_bits[cbpc+16], |
1147 inter_MCBPC_code[cbpc+16]); | |
453 | 1148 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]); |
1149 | |
757 | 1150 if(!s->progressive_sequence){ |
1151 if(cbp) | |
1152 put_bits(pb2, 1, s->interlaced_dct); | |
1153 } | |
2967 | 1154 |
453 | 1155 if(interleaved_stats){ |
1164 | 1156 s->misc_bits+= get_bits_diff(s); |
453 | 1157 } |
324 | 1158 |
1159 for(i=0; i<4; i++){ | |
1160 /* motion vectors: 8x8 mode*/ | |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
1161 h263_pred_motion(s, i, 0, &pred_x, &pred_y); |
324 | 1162 |
2502 | 1163 ff_h263_encode_motion_vector(s, s->current_picture.motion_val[0][ s->block_index[i] ][0] - pred_x, |
1164 s->current_picture.motion_val[0][ s->block_index[i] ][1] - pred_y, s->f_code); | |
324 | 1165 } |
1166 } | |
453 | 1167 |
2967 | 1168 if(interleaved_stats){ |
1164 | 1169 s->mv_bits+= get_bits_diff(s); |
453 | 1170 } |
324 | 1171 |
2502 | 1172 mpeg4_encode_blocks(s, block, NULL, NULL, NULL, tex_pb); |
453 | 1173 |
1174 if(interleaved_stats){ | |
1164 | 1175 s->p_tex_bits+= get_bits_diff(s); |
453 | 1176 } |
656
e47fa3e3f2d5
statistics for forw & back p-MBs instead of just one counter for both
michaelni
parents:
654
diff
changeset
|
1177 s->f_count++; |
295 | 1178 } |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1179 } else { |
324 | 1180 int cbp; |
2967 | 1181 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
|
1182 int dir[6]; //prediction direction |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1183 int zigzag_last_index[6]; |
2979 | 1184 uint8_t *scan_table[6]; |
1057 | 1185 int i; |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1186 |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1187 for(i=0; i<6; i++){ |
2003 | 1188 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
|
1189 } |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1190 |
1492 | 1191 if(s->flags & CODEC_FLAG_AC_PRED){ |
1192 s->ac_pred= decide_ac_pred(s, block, dir, scan_table, zigzag_last_index); | |
1193 if(!s->ac_pred) | |
1194 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
|
1195 }else{ |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1196 for(i=0; i<6; i++) |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
702
diff
changeset
|
1197 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
|
1198 } |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1199 |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1200 /* compute cbp */ |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1201 cbp = 0; |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1202 for (i = 0; i < 6; i++) { |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1203 if (s->block_last_index[i] >= 1) |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1204 cbp |= 1 << (5 - i); |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1205 } |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1206 |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1207 cbpc = cbp & 3; |
6481 | 1208 if (s->pict_type == FF_I_TYPE) { |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
1209 if(s->dquant) cbpc+=4; |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1210 put_bits(&s->pb, |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1211 intra_MCBPC_bits[cbpc], |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1212 intra_MCBPC_code[cbpc]); |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1213 } else { |
690
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
1214 if(s->dquant) cbpc+=8; |
2979 | 1215 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
|
1216 put_bits(&s->pb, |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1217 inter_MCBPC_bits[cbpc + 4], |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1218 inter_MCBPC_code[cbpc + 4]); |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1219 } |
453 | 1220 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
|
1221 cbpy = cbp >> 2; |
453 | 1222 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
|
1223 if(s->dquant) |
a1c69cb685b3
adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents:
676
diff
changeset
|
1224 put_bits(dc_pb, 2, dquant_code[s->dquant+2]); |
453 | 1225 |
697 | 1226 if(!s->progressive_sequence){ |
1227 put_bits(dc_pb, 1, s->interlaced_dct); | |
1228 } | |
1229 | |
453 | 1230 if(interleaved_stats){ |
1164 | 1231 s->misc_bits+= get_bits_diff(s); |
453 | 1232 } |
286 | 1233 |
2502 | 1234 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
|
1235 |
453 | 1236 if(interleaved_stats){ |
1164 | 1237 s->i_tex_bits+= get_bits_diff(s); |
453 | 1238 } |
286 | 1239 s->i_count++; |
1240 | |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1241 /* restore ac coeffs & last_index stuff if we messed them up with the prediction */ |
1492 | 1242 if(s->ac_pred) |
1243 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
|
1244 } |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1245 } |
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
1246 |
0 | 1247 void h263_encode_mb(MpegEncContext * s, |
2979 | 1248 DCTELEM block[6][64], |
1249 int motion_x, int motion_y) | |
0 | 1250 { |
1251 int cbpc, cbpy, i, cbp, pred_x, pred_y; | |
1064 | 1252 int16_t pred_dc; |
1253 int16_t rec_intradc[6]; | |
3781 | 1254 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
|
1255 const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1); |
2967 | 1256 |
324 | 1257 if (!s->mb_intra) { |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1258 /* compute cbp */ |
1490
0355f2b3519a
rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents:
1483
diff
changeset
|
1259 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
|
1260 |
1789 | 1261 if ((cbp | motion_x | motion_y | s->dquant | (s->mv_type - MV_TYPE_16X16)) == 0) { |
324 | 1262 /* skip macroblock */ |
1263 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
|
1264 if(interleaved_stats){ |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1265 s->misc_bits++; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1266 s->last_bits++; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1267 } |
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
|
1268 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
|
1269 |
324 | 1270 return; |
1271 } | |
2979 | 1272 put_bits(&s->pb, 1, 0); /* mb coded */ |
2967 | 1273 |
324 | 1274 cbpc = cbp & 3; |
1637 | 1275 cbpy = cbp >> 2; |
1276 if(s->alt_inter_vlc==0 || cbpc!=3) | |
1277 cbpy ^= 0xF; | |
695 | 1278 if(s->dquant) cbpc+= 8; |
1633 | 1279 if(s->mv_type==MV_TYPE_16X16){ |
1280 put_bits(&s->pb, | |
1281 inter_MCBPC_bits[cbpc], | |
1282 inter_MCBPC_code[cbpc]); | |
1283 | |
1284 put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]); | |
1285 if(s->dquant) | |
1286 put_bits(&s->pb, 2, dquant_code[s->dquant+2]); | |
2967 | 1287 |
1633 | 1288 if(interleaved_stats){ |
1289 s->misc_bits+= get_bits_diff(s); | |
1290 } | |
1291 | |
1292 /* motion vectors: 16x16 mode */ | |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
1293 h263_pred_motion(s, 0, 0, &pred_x, &pred_y); |
2967 | 1294 |
1295 if (!s->umvplus) { | |
2502 | 1296 ff_h263_encode_motion_vector(s, motion_x - pred_x, |
1297 motion_y - pred_y, 1); | |
1633 | 1298 } |
1299 else { | |
1300 h263p_encode_umotion(s, motion_x - pred_x); | |
1301 h263p_encode_umotion(s, motion_y - pred_y); | |
1302 if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1)) | |
1303 /* To prevent Start Code emulation */ | |
1304 put_bits(&s->pb,1,1); | |
1305 } | |
1306 }else{ | |
1307 put_bits(&s->pb, | |
1308 inter_MCBPC_bits[cbpc+16], | |
1309 inter_MCBPC_code[cbpc+16]); | |
1310 put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]); | |
1311 if(s->dquant) | |
1312 put_bits(&s->pb, 2, dquant_code[s->dquant+2]); | |
1313 | |
1314 if(interleaved_stats){ | |
1315 s->misc_bits+= get_bits_diff(s); | |
1316 } | |
1317 | |
1318 for(i=0; i<4; i++){ | |
1319 /* motion vectors: 8x8 mode*/ | |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
1320 h263_pred_motion(s, i, 0, &pred_x, &pred_y); |
1633 | 1321 |
1668
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1666
diff
changeset
|
1322 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
|
1323 motion_y= s->current_picture.motion_val[0][ s->block_index[i] ][1]; |
2967 | 1324 if (!s->umvplus) { |
2502 | 1325 ff_h263_encode_motion_vector(s, motion_x - pred_x, |
1326 motion_y - pred_y, 1); | |
1633 | 1327 } |
1328 else { | |
1329 h263p_encode_umotion(s, motion_x - pred_x); | |
1330 h263p_encode_umotion(s, motion_y - pred_y); | |
1331 if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1)) | |
1332 /* To prevent Start Code emulation */ | |
1333 put_bits(&s->pb,1,1); | |
1334 } | |
1335 } | |
324 | 1336 } |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1337 |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1338 if(interleaved_stats){ |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1339 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
|
1340 } |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1341 } else { |
1639 | 1342 assert(s->mb_intra); |
2967 | 1343 |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1344 cbp = 0; |
1666 | 1345 if (s->h263_aic) { |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1346 /* Predict DC */ |
1666 | 1347 for(i=0; i<6; i++) { |
1064 | 1348 int16_t level = block[i][0]; |
1666 | 1349 int scale; |
2967 | 1350 |
1666 | 1351 if(i<4) scale= s->y_dc_scale; |
1352 else scale= s->c_dc_scale; | |
1353 | |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1354 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
|
1355 level -= pred_dc; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1356 /* Quant */ |
1666 | 1357 if (level >= 0) |
1358 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
|
1359 else |
1666 | 1360 level = (level - (scale>>1))/scale; |
2967 | 1361 |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1362 /* AIC can change CBP */ |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1363 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
|
1364 s->block_last_index[i] = -1; |
1666 | 1365 |
1366 if(!s->modified_quant){ | |
1367 if (level < -127) | |
1368 level = -127; | |
1369 else if (level > 127) | |
1370 level = 127; | |
1371 } | |
1372 | |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1373 block[i][0] = level; |
2967 | 1374 /* Reconstruction */ |
1666 | 1375 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
|
1376 /* Oddify */ |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1377 rec_intradc[i] |= 1; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1378 //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
|
1379 // rec_intradc[i]++; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1380 /* Clipping */ |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1381 if (rec_intradc[i] < 0) |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1382 rec_intradc[i] = 0; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1383 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
|
1384 rec_intradc[i] = 2047; |
2967 | 1385 |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1386 /* Update AC/DC tables */ |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1387 *dc_ptr[i] = rec_intradc[i]; |
1666 | 1388 if (s->block_last_index[i] >= 0) |
1389 cbp |= 1 << (5 - i); | |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1390 } |
1666 | 1391 }else{ |
1392 for(i=0; i<6; i++) { | |
1393 /* compute cbp */ | |
1394 if (s->block_last_index[i] >= 1) | |
1395 cbp |= 1 << (5 - i); | |
1396 } | |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1397 } |
0 | 1398 |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1399 cbpc = cbp & 3; |
6481 | 1400 if (s->pict_type == FF_I_TYPE) { |
695 | 1401 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
|
1402 put_bits(&s->pb, |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1403 intra_MCBPC_bits[cbpc], |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1404 intra_MCBPC_code[cbpc]); |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1405 } else { |
695 | 1406 if(s->dquant) cbpc+=8; |
2979 | 1407 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
|
1408 put_bits(&s->pb, |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1409 inter_MCBPC_bits[cbpc + 4], |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1410 inter_MCBPC_code[cbpc + 4]); |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1411 } |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1412 if (s->h263_aic) { |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1413 /* XXX: currently, we do not try to use ac prediction */ |
2979 | 1414 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
|
1415 } |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1416 cbpy = cbp >> 2; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1417 put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]); |
695 | 1418 if(s->dquant) |
1419 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
|
1420 |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1421 if(interleaved_stats){ |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1422 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
|
1423 } |
0 | 1424 } |
1425 | |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1426 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
|
1427 /* encode each block */ |
1354 | 1428 h263_encode_block(s, block[i], i); |
2967 | 1429 |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1430 /* Update INTRADC for decoding */ |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1431 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
|
1432 block[i][0] = rec_intradc[i]; |
2967 | 1433 |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1434 } |
0 | 1435 } |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1436 |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1437 if(interleaved_stats){ |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1438 if (!s->mb_intra) { |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1439 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
|
1440 s->f_count++; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1441 }else{ |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1442 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
|
1443 s->i_count++; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1444 } |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
1445 } |
0 | 1446 } |
815
78accc54493b
put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents:
770
diff
changeset
|
1447 #endif |
0 | 1448 |
1656 | 1449 void ff_h263_loop_filter(MpegEncContext * s){ |
1644 | 1450 int qp_c; |
1451 const int linesize = s->linesize; | |
1452 const int uvlinesize= s->uvlinesize; | |
1453 const int xy = s->mb_y * s->mb_stride + s->mb_x; | |
1454 uint8_t *dest_y = s->dest[0]; | |
1455 uint8_t *dest_cb= s->dest[1]; | |
1456 uint8_t *dest_cr= s->dest[2]; | |
2967 | 1457 |
6481 | 1458 // if(s->pict_type==FF_B_TYPE && !s->readable) return; |
1644 | 1459 |
1460 /* | |
1461 Diag Top | |
1462 Left Center | |
1463 */ | |
1464 if(!IS_SKIP(s->current_picture.mb_type[xy])){ | |
1465 qp_c= s->qscale; | |
1466 s->dsp.h263_v_loop_filter(dest_y+8*linesize , linesize, qp_c); | |
1467 s->dsp.h263_v_loop_filter(dest_y+8*linesize+8, linesize, qp_c); | |
1468 }else | |
1469 qp_c= 0; | |
1470 | |
1471 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
|
1472 int qp_dt, qp_tt, qp_tc; |
1644 | 1473 |
1474 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
|
1475 qp_tt=0; |
2967 | 1476 else |
8297
20e0f0809b27
s/qp_t/qp_tt/ to avoid bad examples that could lead to issues with reserved
michael
parents:
8288
diff
changeset
|
1477 qp_tt= s->current_picture.qscale_table[xy-s->mb_stride]; |
1644 | 1478 |
2967 | 1479 if(qp_c) |
1644 | 1480 qp_tc= qp_c; |
1481 else | |
8297
20e0f0809b27
s/qp_t/qp_tt/ to avoid bad examples that could lead to issues with reserved
michael
parents:
8288
diff
changeset
|
1482 qp_tc= qp_tt; |
2967 | 1483 |
1644 | 1484 if(qp_tc){ |
1485 const int chroma_qp= s->chroma_qscale_table[qp_tc]; | |
1486 s->dsp.h263_v_loop_filter(dest_y , linesize, qp_tc); | |
1487 s->dsp.h263_v_loop_filter(dest_y+8, linesize, qp_tc); | |
2967 | 1488 |
1644 | 1489 s->dsp.h263_v_loop_filter(dest_cb , uvlinesize, chroma_qp); |
1490 s->dsp.h263_v_loop_filter(dest_cr , uvlinesize, chroma_qp); | |
1491 } | |
2967 | 1492 |
8297
20e0f0809b27
s/qp_t/qp_tt/ to avoid bad examples that could lead to issues with reserved
michael
parents:
8288
diff
changeset
|
1493 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
|
1494 s->dsp.h263_h_loop_filter(dest_y-8*linesize+8 , linesize, qp_tt); |
2967 | 1495 |
1644 | 1496 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
|
1497 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
|
1498 qp_dt= qp_tt; |
1644 | 1499 else |
1500 qp_dt= s->current_picture.qscale_table[xy-1-s->mb_stride]; | |
2967 | 1501 |
1644 | 1502 if(qp_dt){ |
1503 const int chroma_qp= s->chroma_qscale_table[qp_dt]; | |
1504 s->dsp.h263_h_loop_filter(dest_y -8*linesize , linesize, qp_dt); | |
1505 s->dsp.h263_h_loop_filter(dest_cb-8*uvlinesize, uvlinesize, chroma_qp); | |
2178 | 1506 s->dsp.h263_h_loop_filter(dest_cr-8*uvlinesize, uvlinesize, chroma_qp); |
1644 | 1507 } |
1508 } | |
1509 } | |
1510 | |
1511 if(qp_c){ | |
1512 s->dsp.h263_h_loop_filter(dest_y +8, linesize, qp_c); | |
1513 if(s->mb_y + 1 == s->mb_height) | |
1514 s->dsp.h263_h_loop_filter(dest_y+8*linesize+8, linesize, qp_c); | |
1515 } | |
2967 | 1516 |
1644 | 1517 if(s->mb_x){ |
1518 int qp_lc; | |
1519 if(qp_c || IS_SKIP(s->current_picture.mb_type[xy-1])) | |
1520 qp_lc= qp_c; | |
1521 else | |
1522 qp_lc= s->current_picture.qscale_table[xy-1]; | |
2967 | 1523 |
1644 | 1524 if(qp_lc){ |
1525 s->dsp.h263_h_loop_filter(dest_y, linesize, qp_lc); | |
1526 if(s->mb_y + 1 == s->mb_height){ | |
1527 const int chroma_qp= s->chroma_qscale_table[qp_lc]; | |
1528 s->dsp.h263_h_loop_filter(dest_y +8* linesize, linesize, qp_lc); | |
1529 s->dsp.h263_h_loop_filter(dest_cb , uvlinesize, chroma_qp); | |
1530 s->dsp.h263_h_loop_filter(dest_cr , uvlinesize, chroma_qp); | |
1531 } | |
1532 } | |
1533 } | |
1534 } | |
1535 | |
8590 | 1536 #if CONFIG_ENCODERS |
3781 | 1537 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
|
1538 { |
9481
44ea854a14b7
Remove several useless writes to variables, found by CSA.
michael
parents:
9465
diff
changeset
|
1539 int x, y, wrap, a, c, pred_dc; |
3781 | 1540 int16_t *dc_val; |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1541 |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1542 /* find prediction */ |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1543 if (n < 4) { |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
1544 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
|
1545 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
|
1546 wrap = s->b8_stride; |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1547 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
|
1548 } else { |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
1549 x = s->mb_x; |
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
1550 y = s->mb_y; |
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
1551 wrap = s->mb_stride; |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1552 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
|
1553 } |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1554 /* B C |
2967 | 1555 * A X |
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 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
|
1558 c = dc_val[(x) + (y - 1) * wrap]; |
2967 | 1559 |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1560 /* 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
|
1561 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
|
1562 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
|
1563 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
|
1564 } |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1565 /* just DC prediction */ |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1566 if (a != 1024 && c != 1024) |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1567 pred_dc = (a + c) >> 1; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1568 else if (a != 1024) |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1569 pred_dc = a; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1570 else |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1571 pred_dc = c; |
2967 | 1572 |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1573 /* we assume pred is positive */ |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1574 *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
|
1575 return pred_dc; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1576 } |
3777 | 1577 #endif /* CONFIG_ENCODERS */ |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1578 |
1057 | 1579 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
|
1580 { |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1581 int x, y, wrap, a, c, pred_dc, scale, i; |
3781 | 1582 int16_t *dc_val, *ac_val, *ac_val1; |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1583 |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1584 /* find prediction */ |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1585 if (n < 4) { |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
1586 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
|
1587 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
|
1588 wrap = s->b8_stride; |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1589 dc_val = s->dc_val[0]; |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1590 ac_val = s->ac_val[0][0]; |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1591 scale = s->y_dc_scale; |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1592 } else { |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
1593 x = s->mb_x; |
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
1594 y = s->mb_y; |
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
1595 wrap = s->mb_stride; |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1596 dc_val = s->dc_val[n - 4 + 1]; |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1597 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
|
1598 scale = s->c_dc_scale; |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1599 } |
2967 | 1600 |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1601 ac_val += ((y) * wrap + (x)) * 16; |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1602 ac_val1 = ac_val; |
2967 | 1603 |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1604 /* B C |
2967 | 1605 * A X |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1606 */ |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1607 a = dc_val[(x - 1) + (y) * wrap]; |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1608 c = dc_val[(x) + (y - 1) * wrap]; |
2967 | 1609 |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
1610 /* No prediction outside GOB boundary */ |
1639 | 1611 if(s->first_slice_line && n!=3){ |
1612 if(n!=2) c= 1024; | |
1613 if(n!=1 && s->mb_x == s->resync_mb_x) a= 1024; | |
1614 } | |
2967 | 1615 |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1616 if (s->ac_pred) { |
1639 | 1617 pred_dc = 1024; |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1618 if (s->h263_aic_dir) { |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1619 /* left prediction */ |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1620 if (a != 1024) { |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1621 ac_val -= 16; |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1622 for(i=1;i<8;i++) { |
1092 | 1623 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
|
1624 } |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1625 pred_dc = a; |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1626 } |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1627 } else { |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1628 /* top prediction */ |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1629 if (c != 1024) { |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1630 ac_val -= 16 * wrap; |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1631 for(i=1;i<8;i++) { |
1092 | 1632 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
|
1633 } |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1634 pred_dc = c; |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1635 } |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1636 } |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1637 } else { |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1638 /* just DC prediction */ |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1639 if (a != 1024 && c != 1024) |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1640 pred_dc = (a + c) >> 1; |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1641 else if (a != 1024) |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1642 pred_dc = a; |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1643 else |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1644 pred_dc = c; |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1645 } |
2967 | 1646 |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1647 /* we assume pred is positive */ |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1648 block[0]=block[0]*scale + pred_dc; |
2967 | 1649 |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1650 if (block[0] < 0) |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1651 block[0] = 0; |
2967 | 1652 else |
1639 | 1653 block[0] |= 1; |
2967 | 1654 |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1655 /* Update AC/DC tables */ |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
1656 dc_val[(x) + (y) * wrap] = block[0]; |
2967 | 1657 |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1658 /* left copy */ |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1659 for(i=1;i<8;i++) |
1092 | 1660 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
|
1661 /* top copy */ |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1662 for(i=1;i<8;i++) |
1092 | 1663 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
|
1664 } |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
1665 |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
1666 int16_t *h263_pred_motion(MpegEncContext * s, int block, int dir, |
0 | 1667 int *px, int *py) |
1668 { | |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
1669 int wrap; |
1655 | 1670 int16_t *A, *B, *C, (*mot_val)[2]; |
1671 static const int off[4]= {2, 1, 1, -1}; | |
1672 | |
1673 wrap = s->b8_stride; | |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
1674 mot_val = s->current_picture.motion_val[dir] + s->block_index[block]; |
1655 | 1675 |
1676 A = mot_val[ - 1]; | |
1677 /* special case for first (slice) line */ | |
1678 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
|
1679 // we can't just change some MVs to simulate that as we need them for the B frames (and ME) |
1655 | 1680 // and if we ever support non rectangular objects than we need to do a few ifs here anyway :( |
1681 if(block==0){ //most common case | |
1682 if(s->mb_x == s->resync_mb_x){ //rare | |
1683 *px= *py = 0; | |
1684 }else if(s->mb_x + 1 == s->resync_mb_x && s->h263_pred){ //rare | |
1685 C = mot_val[off[block] - wrap]; | |
1686 if(s->mb_x==0){ | |
1687 *px = C[0]; | |
1688 *py = C[1]; | |
1689 }else{ | |
1690 *px = mid_pred(A[0], 0, C[0]); | |
1691 *py = mid_pred(A[1], 0, C[1]); | |
1692 } | |
1693 }else{ | |
1694 *px = A[0]; | |
1695 *py = A[1]; | |
1696 } | |
1697 }else if(block==1){ | |
1698 if(s->mb_x + 1 == s->resync_mb_x && s->h263_pred){ //rare | |
1699 C = mot_val[off[block] - wrap]; | |
1700 *px = mid_pred(A[0], 0, C[0]); | |
1701 *py = mid_pred(A[1], 0, C[1]); | |
1702 }else{ | |
1703 *px = A[0]; | |
1704 *py = A[1]; | |
1705 } | |
1706 }else{ /* block==2*/ | |
1707 B = mot_val[ - wrap]; | |
1708 C = mot_val[off[block] - wrap]; | |
1709 if(s->mb_x == s->resync_mb_x) //rare | |
1710 A[0]=A[1]=0; | |
2967 | 1711 |
1655 | 1712 *px = mid_pred(A[0], B[0], C[0]); |
1713 *py = mid_pred(A[1], B[1], C[1]); | |
1714 } | |
1715 } else { | |
1716 B = mot_val[ - wrap]; | |
1717 C = mot_val[off[block] - wrap]; | |
1718 *px = mid_pred(A[0], B[0], C[0]); | |
1719 *py = mid_pred(A[1], B[1], C[1]); | |
1720 } | |
1721 return *mot_val; | |
1722 } | |
1723 | |
8590 | 1724 #if CONFIG_ENCODERS |
2017 | 1725 void ff_h263_encode_motion(MpegEncContext * s, int val, int f_code) |
0 | 1726 { |
702 | 1727 int range, l, bit_size, sign, code, bits; |
0 | 1728 |
1729 if (val == 0) { | |
1730 /* zero vector */ | |
1731 code = 0; | |
1732 put_bits(&s->pb, mvtab[code][1], mvtab[code][0]); | |
1733 } else { | |
324 | 1734 bit_size = f_code - 1; |
0 | 1735 range = 1 << bit_size; |
1736 /* modulo encoding */ | |
2093 | 1737 l= INT_BIT - 6 - bit_size; |
1738 val = (val<<l)>>l; | |
702 | 1739 sign = val>>31; |
1740 val= (val^sign)-sign; | |
1741 sign&=1; | |
2093 | 1742 |
312 | 1743 val--; |
1744 code = (val >> bit_size) + 1; | |
1745 bits = val & (range - 1); | |
0 | 1746 |
2967 | 1747 put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign); |
0 | 1748 if (bit_size > 0) { |
1749 put_bits(&s->pb, bit_size, bits); | |
1750 } | |
1751 } | |
1752 } | |
1753 | |
78 | 1754 /* Encode MV differences on H.263+ with Unrestricted MV mode */ |
1755 static void h263p_encode_umotion(MpegEncContext * s, int val) | |
1756 { | |
2967 | 1757 short sval = 0; |
78 | 1758 short i = 0; |
1759 short n_bits = 0; | |
1760 short temp_val; | |
1761 int code = 0; | |
1762 int tcode; | |
2967 | 1763 |
78 | 1764 if ( val == 0) |
1765 put_bits(&s->pb, 1, 1); | |
1766 else if (val == 1) | |
1767 put_bits(&s->pb, 3, 0); | |
1768 else if (val == -1) | |
1769 put_bits(&s->pb, 3, 2); | |
1770 else { | |
2967 | 1771 |
78 | 1772 sval = ((val < 0) ? (short)(-val):(short)val); |
1773 temp_val = sval; | |
2967 | 1774 |
78 | 1775 while (temp_val != 0) { |
1776 temp_val = temp_val >> 1; | |
1777 n_bits++; | |
1778 } | |
2967 | 1779 |
78 | 1780 i = n_bits - 1; |
1781 while (i > 0) { | |
1782 tcode = (sval & (1 << (i-1))) >> (i-1); | |
1783 tcode = (tcode << 1) | 1; | |
1784 code = (code << 2) | tcode; | |
1785 i--; | |
1786 } | |
1787 code = ((code << 1) | (val < 0)) << 1; | |
1788 put_bits(&s->pb, (2*n_bits)+1, code); | |
1789 } | |
1790 } | |
1791 | |
277
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1792 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
|
1793 { |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1794 int f_code; |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1795 int mv; |
2967 | 1796 |
277
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1797 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
|
1798 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
|
1799 int len; |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1800 |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1801 if(mv==0) len= mvtab[0][1]; |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1802 else{ |
9465
9dcb191f1df3
Remove unused variable in init_mv_penalty_and_fcode() found by CSA.
michael
parents:
9458
diff
changeset
|
1803 int val, bit_size, code; |
277
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1804 |
1893
779bdf5063ce
1000000l (using uninitalized variable for initalizing bits per MV table)
michael
parents:
1873
diff
changeset
|
1805 bit_size = f_code - 1; |
277
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1806 |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1807 val=mv; |
2967 | 1808 if (val < 0) |
277
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1809 val = -val; |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1810 val--; |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1811 code = (val >> bit_size) + 1; |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1812 if(code<33){ |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1813 len= mvtab[code][1] + 1 + bit_size; |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1814 }else{ |
2985 | 1815 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
|
1816 } |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1817 } |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1818 |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1819 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
|
1820 } |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1821 } |
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 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
|
1824 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
|
1825 fcode_tab[mv+MAX_MV]= f_code; |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1826 } |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1827 } |
287 | 1828 |
1829 for(mv=0; mv<MAX_MV*2+1; mv++){ | |
1830 umv_fcode_tab[mv]= 1; | |
1831 } | |
277
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
1832 } |
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
|
1833 |
468 | 1834 static void init_uni_dc_tab(void) |
293 | 1835 { |
1836 int level, uni_code, uni_len; | |
1837 | |
312 | 1838 for(level=-256; level<256; level++){ |
293 | 1839 int size, v, l; |
1840 /* find number of bits */ | |
1841 size = 0; | |
1842 v = abs(level); | |
1843 while (v) { | |
1844 v >>= 1; | |
2979 | 1845 size++; |
293 | 1846 } |
1847 | |
1848 if (level < 0) | |
1849 l= (-level) ^ ((1 << size) - 1); | |
1850 else | |
1851 l= level; | |
1852 | |
1853 /* luminance */ | |
1854 uni_code= DCtab_lum[size][0]; | |
1855 uni_len = DCtab_lum[size][1]; | |
1856 | |
1857 if (size > 0) { | |
1858 uni_code<<=size; uni_code|=l; | |
1859 uni_len+=size; | |
1860 if (size > 8){ | |
1861 uni_code<<=1; uni_code|=1; | |
1862 uni_len++; | |
1863 } | |
1864 } | |
1013 | 1865 uni_DCtab_lum_bits[level+256]= uni_code; |
1866 uni_DCtab_lum_len [level+256]= uni_len; | |
293 | 1867 |
1868 /* chrominance */ | |
1869 uni_code= DCtab_chrom[size][0]; | |
1870 uni_len = DCtab_chrom[size][1]; | |
2967 | 1871 |
293 | 1872 if (size > 0) { |
1873 uni_code<<=size; uni_code|=l; | |
1874 uni_len+=size; | |
1875 if (size > 8){ | |
1876 uni_code<<=1; uni_code|=1; | |
1877 uni_len++; | |
1878 } | |
1879 } | |
1013 | 1880 uni_DCtab_chrom_bits[level+256]= uni_code; |
1881 uni_DCtab_chrom_len [level+256]= uni_len; | |
293 | 1882 |
1883 } | |
1884 } | |
1885 | |
1064 | 1886 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
|
1887 int slevel, run, last; |
2967 | 1888 |
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
|
1889 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
|
1890 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
|
1891 |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
1892 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
|
1893 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
|
1894 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
|
1895 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
|
1896 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
|
1897 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
|
1898 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
|
1899 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
|
1900 int level1, run1; |
2967 | 1901 |
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
|
1902 len_tab[index]= 100; |
2967 | 1903 |
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
|
1904 /* 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
|
1905 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
|
1906 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
|
1907 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
|
1908 bits=bits*2+sign; len++; |
2967 | 1909 |
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
|
1910 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
|
1911 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
|
1912 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
|
1913 } |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream 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 /* 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
|
1915 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
|
1916 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
|
1917 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
|
1918 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
|
1919 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
|
1920 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
|
1921 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
|
1922 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
|
1923 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
|
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 } |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream 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 /* 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
|
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*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
|
1935 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
|
1936 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
|
1937 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
|
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 /* 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
|
1949 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
|
1950 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
|
1951 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
|
1952 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
|
1953 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
|
1954 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
|
1955 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
|
1956 bits=bits*2+1; len++; //marker |
2967 | 1957 |
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
|
1958 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
|
1959 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
|
1960 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
|
1961 } |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream 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 } |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream 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 } |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream 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 } |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream 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 |
2253 | 1967 static void init_uni_h263_rl_tab(RLTable *rl, uint32_t *bits_tab, uint8_t *len_tab){ |
1968 int slevel, run, last; | |
2967 | 1969 |
2253 | 1970 assert(MAX_LEVEL >= 64); |
1971 assert(MAX_RUN >= 63); | |
1972 | |
1973 for(slevel=-64; slevel<64; slevel++){ | |
1974 if(slevel==0) continue; | |
1975 for(run=0; run<64; run++){ | |
1976 for(last=0; last<=1; last++){ | |
1977 const int index= UNI_MPEG4_ENC_INDEX(last, run, slevel+64); | |
1978 int level= slevel < 0 ? -slevel : slevel; | |
1979 int sign= slevel < 0 ? 1 : 0; | |
1980 int bits, len, code; | |
2967 | 1981 |
2253 | 1982 len_tab[index]= 100; |
2967 | 1983 |
2253 | 1984 /* ESC0 */ |
1985 code= get_rl_index(rl, last, run, level); | |
1986 bits= rl->table_vlc[code][0]; | |
1987 len= rl->table_vlc[code][1]; | |
1988 bits=bits*2+sign; len++; | |
2967 | 1989 |
2253 | 1990 if(code!=rl->n && len < len_tab[index]){ |
1991 if(bits_tab) bits_tab[index]= bits; | |
1992 len_tab [index]= len; | |
1993 } | |
1994 /* ESC */ | |
1995 bits= rl->table_vlc[rl->n][0]; | |
1996 len = rl->table_vlc[rl->n][1]; | |
1997 bits=bits*2+last; len++; | |
1998 bits=bits*64+run; len+=6; | |
1999 bits=bits*256+(level&0xff); len+=8; | |
2967 | 2000 |
2253 | 2001 if(len < len_tab[index]){ |
2002 if(bits_tab) bits_tab[index]= bits; | |
2003 len_tab [index]= len; | |
2004 } | |
2005 } | |
2006 } | |
2007 } | |
2008 } | |
2009 | |
277
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
2010 void h263_encode_init(MpegEncContext *s) |
0 | 2011 { |
2012 static int done = 0; | |
2013 | |
2014 if (!done) { | |
2015 done = 1; | |
293 | 2016 |
2017 init_uni_dc_tab(); | |
2018 | |
4668 | 2019 init_rl(&rl_inter, static_rl_table_store[0]); |
2020 init_rl(&rl_intra, static_rl_table_store[1]); | |
2021 init_rl(&rl_intra_aic, static_rl_table_store[2]); | |
2967 | 2022 |
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
|
2023 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
|
2024 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
|
2025 |
2253 | 2026 init_uni_h263_rl_tab(&rl_intra_aic, NULL, uni_h263_intra_aic_rl_len); |
2027 init_uni_h263_rl_tab(&rl_inter , NULL, uni_h263_inter_rl_len); | |
2028 | |
277
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
274
diff
changeset
|
2029 init_mv_penalty_and_fcode(s); |
0 | 2030 } |
936 | 2031 s->me.mv_penalty= mv_penalty; //FIXME exact table for msmpeg4 & h263p |
2967 | 2032 |
2253 | 2033 s->intra_ac_vlc_length =s->inter_ac_vlc_length = uni_h263_inter_rl_len; |
2034 s->intra_ac_vlc_last_length=s->inter_ac_vlc_last_length= uni_h263_inter_rl_len + 128*64; | |
2035 if(s->h263_aic){ | |
2036 s->intra_ac_vlc_length = uni_h263_intra_aic_rl_len; | |
2037 s->intra_ac_vlc_last_length= uni_h263_intra_aic_rl_len + 128*64; | |
2038 } | |
2039 s->ac_esc_length= 7+1+6+8; | |
2040 | |
287 | 2041 // use fcodes >1 only for mpeg4 & h263 & h263p FIXME |
344 | 2042 switch(s->codec_id){ |
2043 case CODEC_ID_MPEG4: | |
2044 s->fcode_tab= fcode_tab; | |
2045 s->min_qcoeff= -2048; | |
2046 s->max_qcoeff= 2047; | |
945 | 2047 s->intra_ac_vlc_length = uni_mpeg4_intra_rl_len; |
2048 s->intra_ac_vlc_last_length= uni_mpeg4_intra_rl_len + 128*64; | |
2049 s->inter_ac_vlc_length = uni_mpeg4_inter_rl_len; | |
2050 s->inter_ac_vlc_last_length= uni_mpeg4_inter_rl_len + 128*64; | |
1013 | 2051 s->luma_dc_vlc_length= uni_DCtab_lum_len; |
2052 s->chroma_dc_vlc_length= uni_DCtab_chrom_len; | |
945 | 2053 s->ac_esc_length= 7+2+1+6+1+12+1; |
1799 | 2054 s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table; |
2055 s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table; | |
2056 | |
1424 | 2057 if(s->flags & CODEC_FLAG_GLOBAL_HEADER){ |
1483 | 2058 |
1424 | 2059 s->avctx->extradata= av_malloc(1024); |
1522
79dddc5cd990
removed the obsolete and unused parameters of init_put_bits
alex
parents:
1521
diff
changeset
|
2060 init_put_bits(&s->pb, s->avctx->extradata, 1024); |
2967 | 2061 |
2572
c22ad129a91b
support omiting various headers in mpeg4 as WMP seems to have difficulty with them
michael
parents:
2554
diff
changeset
|
2062 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
|
2063 mpeg4_encode_visual_object_header(s); |
1424 | 2064 mpeg4_encode_vol_header(s, 0, 0); |
2065 | |
2066 // ff_mpeg4_stuffing(&s->pb); ? | |
2067 flush_put_bits(&s->pb); | |
1786 | 2068 s->avctx->extradata_size= (put_bits_count(&s->pb)+7)>>3; |
1424 | 2069 } |
2967 | 2070 |
344 | 2071 break; |
2072 case CODEC_ID_H263P: | |
1666 | 2073 if(s->umvplus) |
2074 s->fcode_tab= umv_fcode_tab; | |
2075 if(s->modified_quant){ | |
2076 s->min_qcoeff= -2047; | |
2077 s->max_qcoeff= 2047; | |
2078 }else{ | |
2079 s->min_qcoeff= -127; | |
2080 s->max_qcoeff= 127; | |
2081 } | |
344 | 2082 break; |
2967 | 2083 //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
|
2084 case CODEC_ID_FLV1: |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
2085 if (s->h263_flv > 1) { |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
2086 s->min_qcoeff= -1023; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
2087 s->max_qcoeff= 1023; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
2088 } else { |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
2089 s->min_qcoeff= -127; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
2090 s->max_qcoeff= 127; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
2091 } |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
2092 s->y_dc_scale_table= |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
2093 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
|
2094 break; |
2646
c735e3e60ca7
Even More spelling errors. patch by (Kevin Baragona <kevinmb500 gawab com)
michael
parents:
2639
diff
changeset
|
2095 default: //nothing needed - default table already set in mpegvideo.c |
1089 | 2096 s->min_qcoeff= -127; |
344 | 2097 s->max_qcoeff= 127; |
498 | 2098 s->y_dc_scale_table= |
2099 s->c_dc_scale_table= ff_mpeg1_dc_scale_table; | |
344 | 2100 } |
0 | 2101 } |
2102 | |
1034 | 2103 /** |
2104 * encodes a 8x8 block. | |
2105 * @param block the 8x8 block | |
2106 * @param n block index (0-3 are luma, 4-5 are chroma) | |
2107 */ | |
0 | 2108 static void h263_encode_block(MpegEncContext * s, DCTELEM * block, int n) |
2109 { | |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
2110 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
|
2111 RLTable *rl; |
0 | 2112 |
350
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
2113 rl = &rl_inter; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
2114 if (s->mb_intra && !s->h263_aic) { |
231 | 2115 /* DC coef */ |
1089 | 2116 level = block[0]; |
0 | 2117 /* 255 cannot be represented, so we clamp */ |
2118 if (level > 254) { | |
2119 level = 254; | |
2120 block[0] = 254; | |
2121 } | |
231 | 2122 /* 0 cannot be represented also */ |
1089 | 2123 else if (level < 1) { |
231 | 2124 level = 1; |
2125 block[0] = 1; | |
2126 } | |
1090 | 2127 if (level == 128) //FIXME check rv10 |
1089 | 2128 put_bits(&s->pb, 8, 0xff); |
2129 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
|
2130 put_bits(&s->pb, 8, level); |
1089 | 2131 i = 1; |
0 | 2132 } else { |
1089 | 2133 i = 0; |
2134 if (s->h263_aic && s->mb_intra) | |
2135 rl = &rl_intra_aic; | |
2967 | 2136 |
1637 | 2137 if(s->alt_inter_vlc && !s->mb_intra){ |
2138 int aic_vlc_bits=0; | |
2139 int inter_vlc_bits=0; | |
2140 int wrong_pos=-1; | |
2141 int aic_code; | |
2967 | 2142 |
1637 | 2143 last_index = s->block_last_index[n]; |
2144 last_non_zero = i - 1; | |
2145 for (; i <= last_index; i++) { | |
2146 j = s->intra_scantable.permutated[i]; | |
2147 level = block[j]; | |
2148 if (level) { | |
2149 run = i - last_non_zero - 1; | |
2150 last = (i == last_index); | |
2967 | 2151 |
1663 | 2152 if(level<0) level= -level; |
2967 | 2153 |
1637 | 2154 code = get_rl_index(rl, last, run, level); |
2155 aic_code = get_rl_index(&rl_intra_aic, last, run, level); | |
2156 inter_vlc_bits += rl->table_vlc[code][1]+1; | |
2157 aic_vlc_bits += rl_intra_aic.table_vlc[aic_code][1]+1; | |
2158 | |
2159 if (code == rl->n) { | |
1663 | 2160 inter_vlc_bits += 1+6+8-1; |
2967 | 2161 } |
1637 | 2162 if (aic_code == rl_intra_aic.n) { |
1663 | 2163 aic_vlc_bits += 1+6+8-1; |
1637 | 2164 wrong_pos += run + 1; |
2165 }else | |
2166 wrong_pos += wrong_run[aic_code]; | |
2167 last_non_zero = i; | |
2967 | 2168 } |
1637 | 2169 } |
2170 i = 0; | |
2171 if(aic_vlc_bits < inter_vlc_bits && wrong_pos > 63) | |
2172 rl = &rl_intra_aic; | |
2173 } | |
0 | 2174 } |
2967 | 2175 |
0 | 2176 /* AC coefs */ |
2177 last_index = s->block_last_index[n]; | |
2178 last_non_zero = i - 1; | |
2179 for (; i <= last_index; i++) { | |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
702
diff
changeset
|
2180 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
|
2181 level = block[j]; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
2182 if (level) { |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
2183 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
|
2184 last = (i == last_index); |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
2185 sign = 0; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
2186 slevel = level; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
2187 if (level < 0) { |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
2188 sign = 1; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
2189 level = -level; |
6ebbecc10063
- Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents:
346
diff
changeset
|
2190 } |
0 | 2191 code = get_rl_index(rl, last, run, level); |
2192 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]); | |
2193 if (code == rl->n) { | |
1354 | 2194 if(s->h263_flv <= 1){ |
0 | 2195 put_bits(&s->pb, 1, last); |
2196 put_bits(&s->pb, 6, run); | |
2967 | 2197 |
1089 | 2198 assert(slevel != 0); |
2199 | |
2967 | 2200 if(level < 128) |
7260
3ec34b551aae
bitstream: move put_sbits() from flacenc.c to bitstream.h and use it
ramiro
parents:
7098
diff
changeset
|
2201 put_sbits(&s->pb, 8, slevel); |
1089 | 2202 else{ |
2203 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
|
2204 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
|
2205 put_sbits(&s->pb, 6, slevel>>5); |
1089 | 2206 } |
1354 | 2207 }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
|
2208 if(level < 64) { // 7-bit level |
1354 | 2209 put_bits(&s->pb, 1, 0); |
2210 put_bits(&s->pb, 1, last); | |
2211 put_bits(&s->pb, 6, run); | |
2212 | |
7260
3ec34b551aae
bitstream: move put_sbits() from flacenc.c to bitstream.h and use it
ramiro
parents:
7098
diff
changeset
|
2213 put_sbits(&s->pb, 7, slevel); |
1354 | 2214 } else { |
2215 /* 11-bit level */ | |
2216 put_bits(&s->pb, 1, 1); | |
2217 put_bits(&s->pb, 1, last); | |
2218 put_bits(&s->pb, 6, run); | |
2219 | |
7260
3ec34b551aae
bitstream: move put_sbits() from flacenc.c to bitstream.h and use it
ramiro
parents:
7098
diff
changeset
|
2220 put_sbits(&s->pb, 11, slevel); |
1354 | 2221 } |
2222 } | |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
2223 } else { |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
2224 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
|
2225 } |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
2226 last_non_zero = i; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
2227 } |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
2228 } |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
2229 } |
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
|
2230 |
0 | 2231 /***************************************************/ |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2232 /** |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2233 * add mpeg4 stuffing bits (01...1) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2234 */ |
453 | 2235 void ff_mpeg4_stuffing(PutBitContext * pbc) |
262 | 2236 { |
2237 int length; | |
2238 put_bits(pbc, 1, 0); | |
1786 | 2239 length= (-put_bits_count(pbc))&7; |
453 | 2240 if(length) put_bits(pbc, length, (1<<length)-1); |
262 | 2241 } |
2242 | |
327 | 2243 /* 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
|
2244 void ff_set_mpeg4_time(MpegEncContext * s){ |
6481 | 2245 if(s->pict_type==FF_B_TYPE){ |
3247 | 2246 ff_mpeg4_init_direct_mv(s); |
327 | 2247 }else{ |
2248 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
|
2249 s->time_base= s->time/s->avctx->time_base.den; |
327 | 2250 } |
2251 } | |
2252 | |
942 | 2253 static void mpeg4_encode_gop_header(MpegEncContext * s){ |
2254 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
|
2255 int64_t time; |
2967 | 2256 |
942 | 2257 put_bits(&s->pb, 16, 0); |
2258 put_bits(&s->pb, 16, GOP_STARTCODE); | |
2967 | 2259 |
1831
cd2d7fcfab7a
use AVFrame.pts=AV_NOPTS_VALUE instead of AVFrame.pts=0
michael
parents:
1829
diff
changeset
|
2260 time= s->current_picture_ptr->pts; |
cd2d7fcfab7a
use AVFrame.pts=AV_NOPTS_VALUE instead of AVFrame.pts=0
michael
parents:
1829
diff
changeset
|
2261 if(s->reordered_input_picture[1]) |
cd2d7fcfab7a
use AVFrame.pts=AV_NOPTS_VALUE instead of AVFrame.pts=0
michael
parents:
1829
diff
changeset
|
2262 time= FFMIN(time, s->reordered_input_picture[1]->pts); |
2637 | 2263 time= time*s->avctx->time_base.num; |
2264 | |
2265 seconds= time/s->avctx->time_base.den; | |
942 | 2266 minutes= seconds/60; seconds %= 60; |
2267 hours= minutes/60; minutes %= 60; | |
2268 hours%=24; | |
2269 | |
2270 put_bits(&s->pb, 5, hours); | |
2271 put_bits(&s->pb, 6, minutes); | |
2272 put_bits(&s->pb, 1, 1); | |
2273 put_bits(&s->pb, 6, seconds); | |
2967 | 2274 |
2275 put_bits(&s->pb, 1, !!(s->flags&CODEC_FLAG_CLOSED_GOP)); | |
942 | 2276 put_bits(&s->pb, 1, 0); //broken link == NO |
2967 | 2277 |
2278 s->last_time_base= time / s->avctx->time_base.den; | |
942 | 2279 |
2280 ff_mpeg4_stuffing(&s->pb); | |
2281 } | |
2282 | |
2283 static void mpeg4_encode_visual_object_header(MpegEncContext * s){ | |
2284 int profile_and_level_indication; | |
2285 int vo_ver_id; | |
2967 | 2286 |
2167 | 2287 if(s->avctx->profile != FF_PROFILE_UNKNOWN){ |
2288 profile_and_level_indication = s->avctx->profile << 4; | |
2289 }else if(s->max_b_frames || s->quarter_sample){ | |
2290 profile_and_level_indication= 0xF0; // adv simple | |
2291 }else{ | |
2292 profile_and_level_indication= 0x00; // simple | |
2293 } | |
2294 | |
2295 if(s->avctx->level != FF_LEVEL_UNKNOWN){ | |
2296 profile_and_level_indication |= s->avctx->level; | |
2297 }else{ | |
2298 profile_and_level_indication |= 1; //level 1 | |
2299 } | |
2300 | |
2301 if(profile_and_level_indication>>4 == 0xF){ | |
942 | 2302 vo_ver_id= 5; |
2303 }else{ | |
2304 vo_ver_id= 1; | |
2305 } | |
2167 | 2306 |
942 | 2307 //FIXME levels |
2308 | |
2309 put_bits(&s->pb, 16, 0); | |
2310 put_bits(&s->pb, 16, VOS_STARTCODE); | |
1350
e7c8051e1849
the reference sw doesnt like some legal headers ...
michaelni
parents:
1346
diff
changeset
|
2311 |
942 | 2312 put_bits(&s->pb, 8, profile_and_level_indication); |
1350
e7c8051e1849
the reference sw doesnt like some legal headers ...
michaelni
parents:
1346
diff
changeset
|
2313 |
942 | 2314 put_bits(&s->pb, 16, 0); |
2315 put_bits(&s->pb, 16, VISUAL_OBJ_STARTCODE); | |
2967 | 2316 |
942 | 2317 put_bits(&s->pb, 1, 1); |
2318 put_bits(&s->pb, 4, vo_ver_id); | |
2319 put_bits(&s->pb, 3, 1); //priority | |
2967 | 2320 |
942 | 2321 put_bits(&s->pb, 4, 1); //visual obj type== video obj |
2967 | 2322 |
942 | 2323 put_bits(&s->pb, 1, 0); //video signal type == no clue //FIXME |
2324 | |
2325 ff_mpeg4_stuffing(&s->pb); | |
2326 } | |
2327 | |
2328 static void mpeg4_encode_vol_header(MpegEncContext * s, int vo_number, int vol_number) | |
0 | 2329 { |
942 | 2330 int vo_ver_id; |
336 | 2331 |
8596
68e959302527
replace all occurrence of ENABLE_ by the corresponding CONFIG_, HAVE_ or ARCH_
aurel
parents:
8590
diff
changeset
|
2332 if (!CONFIG_MPEG4_ENCODER) return; |
5275
91416b4f1929
Better place to disable some mpeg4 code and ensure that
aurel
parents:
5274
diff
changeset
|
2333 |
942 | 2334 if(s->max_b_frames || s->quarter_sample){ |
2335 vo_ver_id= 5; | |
923 | 2336 s->vo_type= ADV_SIMPLE_VO_TYPE; |
2337 }else{ | |
942 | 2338 vo_ver_id= 1; |
923 | 2339 s->vo_type= SIMPLE_VO_TYPE; |
2340 } | |
336 | 2341 |
263 | 2342 put_bits(&s->pb, 16, 0); |
942 | 2343 put_bits(&s->pb, 16, 0x100 + vo_number); /* video obj */ |
263 | 2344 put_bits(&s->pb, 16, 0); |
942 | 2345 put_bits(&s->pb, 16, 0x120 + vol_number); /* video obj layer */ |
263 | 2346 |
2979 | 2347 put_bits(&s->pb, 1, 0); /* random access vol */ |
2348 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
|
2349 if(s->workaround_bugs & FF_BUG_MS) { |
2979 | 2350 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
|
2351 } else { |
2979 | 2352 put_bits(&s->pb, 1, 1); /* is obj layer id= yes */ |
2353 put_bits(&s->pb, 4, vo_ver_id); /* is obj layer ver id */ | |
2354 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
|
2355 } |
2967 | 2356 |
1548 | 2357 aspect_to_info(s, s->avctx->sample_aspect_ratio); |
880 | 2358 |
2359 put_bits(&s->pb, 4, s->aspect_ratio_info);/* aspect ratio info */ | |
1548 | 2360 if (s->aspect_ratio_info == FF_ASPECT_EXTENDED){ |
2361 put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.num); | |
2362 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
|
2363 } |
336 | 2364 |
2572
c22ad129a91b
support omiting various headers in mpeg4 as WMP seems to have difficulty with them
michael
parents:
2554
diff
changeset
|
2365 if(s->workaround_bugs & FF_BUG_MS) { // |
2979 | 2366 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
|
2367 } else { |
2979 | 2368 put_bits(&s->pb, 1, 1); /* vol control parameters= yes */ |
2369 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
|
2370 put_bits(&s->pb, 1, s->low_delay); |
2979 | 2371 put_bits(&s->pb, 1, 0); /* vbv parameters= no */ |
2372 } | |
2373 | |
2374 put_bits(&s->pb, 2, RECT_SHAPE); /* vol shape= rectangle */ | |
2375 put_bits(&s->pb, 1, 1); /* marker bit */ | |
2967 | 2376 |
2637 | 2377 put_bits(&s->pb, 16, s->avctx->time_base.den); |
263 | 2378 if (s->time_increment_bits < 1) |
2379 s->time_increment_bits = 1; | |
2979 | 2380 put_bits(&s->pb, 1, 1); /* marker bit */ |
2381 put_bits(&s->pb, 1, 0); /* fixed vop rate=no */ | |
2382 put_bits(&s->pb, 1, 1); /* marker bit */ | |
2383 put_bits(&s->pb, 13, s->width); /* vol width */ | |
2384 put_bits(&s->pb, 1, 1); /* marker bit */ | |
2385 put_bits(&s->pb, 13, s->height); /* vol height */ | |
2386 put_bits(&s->pb, 1, 1); /* marker bit */ | |
697 | 2387 put_bits(&s->pb, 1, s->progressive_sequence ? 0 : 1); |
2979 | 2388 put_bits(&s->pb, 1, 1); /* obmc disable */ |
263 | 2389 if (vo_ver_id == 1) { |
2979 | 2390 put_bits(&s->pb, 1, s->vol_sprite_usage); /* sprite enable */ |
942 | 2391 }else{ |
2979 | 2392 put_bits(&s->pb, 2, s->vol_sprite_usage); /* sprite enable */ |
2393 } | |
2394 | |
2395 put_bits(&s->pb, 1, 0); /* not 8 bit == false */ | |
2396 put_bits(&s->pb, 1, s->mpeg_quant); /* quant type= (0=h263 style)*/ | |
1411 | 2397 |
2398 if(s->mpeg_quant){ | |
2399 ff_write_quant_matrix(&s->pb, s->avctx->intra_matrix); | |
2400 ff_write_quant_matrix(&s->pb, s->avctx->inter_matrix); | |
2401 } | |
599 | 2402 |
263 | 2403 if (vo_ver_id != 1) |
936 | 2404 put_bits(&s->pb, 1, s->quarter_sample); |
2979 | 2405 put_bits(&s->pb, 1, 1); /* complexity estimation disable */ |
453 | 2406 s->resync_marker= s->rtp_mode; |
2407 put_bits(&s->pb, 1, s->resync_marker ? 0 : 1);/* resync marker disable */ | |
2408 put_bits(&s->pb, 1, s->data_partitioning ? 1 : 0); | |
2409 if(s->data_partitioning){ | |
2979 | 2410 put_bits(&s->pb, 1, 0); /* no rvlc */ |
453 | 2411 } |
2412 | |
263 | 2413 if (vo_ver_id != 1){ |
2979 | 2414 put_bits(&s->pb, 1, 0); /* newpred */ |
2415 put_bits(&s->pb, 1, 0); /* reduced res vop */ | |
2416 } | |
2417 put_bits(&s->pb, 1, 0); /* scalability */ | |
2967 | 2418 |
453 | 2419 ff_mpeg4_stuffing(&s->pb); |
676 | 2420 |
2421 /* user data */ | |
1092 | 2422 if(!(s->flags & CODEC_FLAG_BITEXACT)){ |
676 | 2423 put_bits(&s->pb, 16, 0); |
2979 | 2424 put_bits(&s->pb, 16, 0x1B2); /* user_data */ |
2425 ff_put_string(&s->pb, LIBAVCODEC_IDENT, 0); | |
676 | 2426 } |
263 | 2427 } |
2428 | |
2429 /* write mpeg4 VOP header */ | |
2430 void mpeg4_encode_picture_header(MpegEncContext * s, int picture_number) | |
2431 { | |
324 | 2432 int time_incr; |
2433 int time_div, time_mod; | |
2967 | 2434 |
6481 | 2435 if(s->pict_type==FF_I_TYPE){ |
953 | 2436 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
|
2437 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
|
2438 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
|
2439 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
|
2440 mpeg4_encode_vol_header(s, 0, 0); |
942 | 2441 } |
2572
c22ad129a91b
support omiting various headers in mpeg4 as WMP seems to have difficulty with them
michael
parents:
2554
diff
changeset
|
2442 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
|
2443 mpeg4_encode_gop_header(s); |
453 | 2444 } |
2967 | 2445 |
6481 | 2446 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
|
2447 |
2979 | 2448 put_bits(&s->pb, 16, 0); /* vop header */ |
2449 put_bits(&s->pb, 16, VOP_STARTCODE); /* vop header */ | |
2450 put_bits(&s->pb, 2, s->pict_type - 1); /* pict type: I = 0 , P = 1 */ | |
324 | 2451 |
2679 | 2452 assert(s->time>=0); |
2637 | 2453 time_div= s->time/s->avctx->time_base.den; |
2454 time_mod= s->time%s->avctx->time_base.den; | |
324 | 2455 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
|
2456 assert(time_incr >= 0); |
324 | 2457 while(time_incr--) |
2458 put_bits(&s->pb, 1, 1); | |
2967 | 2459 |
0 | 2460 put_bits(&s->pb, 1, 0); |
2461 | |
2979 | 2462 put_bits(&s->pb, 1, 1); /* marker */ |
2463 put_bits(&s->pb, s->time_increment_bits, time_mod); /* time increment */ | |
2464 put_bits(&s->pb, 1, 1); /* marker */ | |
2465 put_bits(&s->pb, 1, 1); /* vop coded */ | |
6481 | 2466 if ( s->pict_type == FF_P_TYPE |
2467 || (s->pict_type == FF_S_TYPE && s->vol_sprite_usage==GMC_SPRITE)) { | |
2979 | 2468 put_bits(&s->pb, 1, s->no_rounding); /* rounding type */ |
2469 } | |
2470 put_bits(&s->pb, 3, 0); /* intra dc VLC threshold */ | |
697 | 2471 if(!s->progressive_sequence){ |
1659 | 2472 put_bits(&s->pb, 1, s->current_picture_ptr->top_field_first); |
697 | 2473 put_bits(&s->pb, 1, s->alternate_scan); |
2474 } | |
263 | 2475 //FIXME sprite stuff |
0 | 2476 |
2477 put_bits(&s->pb, 5, s->qscale); | |
2478 | |
6481 | 2479 if (s->pict_type != FF_I_TYPE) |
2979 | 2480 put_bits(&s->pb, 3, s->f_code); /* fcode_for */ |
6481 | 2481 if (s->pict_type == FF_B_TYPE) |
2979 | 2482 put_bits(&s->pb, 3, s->b_code); /* fcode_back */ |
0 | 2483 } |
2484 | |
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
|
2485 #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
|
2486 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2487 /** |
1034 | 2488 * predicts the dc. |
2003 | 2489 * encoding quantized level -> quantized diff |
2967 | 2490 * decoding quantized diff -> quantized level |
1034 | 2491 * @param n block index (0-3 are luma, 4-5 are chroma) |
2492 * @param dir_ptr pointer to an integer where the prediction direction will be stored | |
2493 */ | |
2003 | 2494 static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, int level, int *dir_ptr, int encoding) |
0 | 2495 { |
2003 | 2496 int a, b, c, wrap, pred, scale, ret; |
3781 | 2497 int16_t *dc_val; |
0 | 2498 |
2499 /* find prediction */ | |
2500 if (n < 4) { | |
2979 | 2501 scale = s->y_dc_scale; |
0 | 2502 } else { |
2979 | 2503 scale = s->c_dc_scale; |
0 | 2504 } |
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
|
2505 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
|
2506 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
|
2507 |
266 | 2508 wrap= s->block_wrap[n]; |
2509 dc_val = s->dc_val[0] + s->block_index[n]; | |
0 | 2510 |
2511 /* B C | |
2967 | 2512 * A X |
0 | 2513 */ |
266 | 2514 a = dc_val[ - 1]; |
2515 b = dc_val[ - 1 - wrap]; | |
2516 c = dc_val[ - wrap]; | |
0 | 2517 |
2646
c735e3e60ca7
Even More spelling errors. patch by (Kevin Baragona <kevinmb500 gawab com)
michael
parents:
2639
diff
changeset
|
2518 /* 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
|
2519 if(s->first_slice_line && n!=3){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2520 if(n!=2) b=c= 1024; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2521 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
|
2522 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2523 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
|
2524 if(n==0 || n==4 || n==5) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2525 b=1024; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2526 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2527 |
0 | 2528 if (abs(a - b) < abs(b - c)) { |
2979 | 2529 pred = c; |
0 | 2530 *dir_ptr = 1; /* top */ |
2531 } else { | |
2979 | 2532 pred = a; |
0 | 2533 *dir_ptr = 0; /* left */ |
2534 } | |
2535 /* 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
|
2536 pred = FASTDIV((pred + (scale >> 1)), scale); |
0 | 2537 |
2003 | 2538 if(encoding){ |
2539 ret = level - pred; | |
2540 }else{ | |
2541 level += pred; | |
2542 ret= level; | |
7831 | 2543 if(s->error_recognition>=3){ |
2003 | 2544 if(level<0){ |
2545 av_log(s->avctx, AV_LOG_ERROR, "dc<0 at %dx%d\n", s->mb_x, s->mb_y); | |
2546 return -1; | |
2547 } | |
2548 if(level*scale > 2048 + scale){ | |
2549 av_log(s->avctx, AV_LOG_ERROR, "dc overflow at %dx%d\n", s->mb_x, s->mb_y); | |
2550 return -1; | |
2551 } | |
2552 } | |
2553 } | |
2554 level *=scale; | |
2004 | 2555 if(level&(~2047)){ |
2967 | 2556 if(level<0) |
2004 | 2557 level=0; |
2558 else if(!(s->workaround_bugs&FF_BUG_DC_CLIP)) | |
2559 level=2047; | |
2560 } | |
2003 | 2561 dc_val[0]= level; |
2562 | |
2563 return ret; | |
0 | 2564 } |
2565 | |
1034 | 2566 /** |
2567 * predicts the ac. | |
2568 * @param n block index (0-3 are luma, 4-5 are chroma) | |
2569 * @param dir the ac prediction direction | |
2570 */ | |
1008 | 2571 void mpeg4_pred_ac(MpegEncContext * s, DCTELEM *block, int n, |
0 | 2572 int dir) |
2573 { | |
266 | 2574 int i; |
1064 | 2575 int16_t *ac_val, *ac_val1; |
903 | 2576 int8_t * const qscale_table= s->current_picture.qscale_table; |
0 | 2577 |
2578 /* find prediction */ | |
266 | 2579 ac_val = s->ac_val[0][0] + s->block_index[n] * 16; |
0 | 2580 ac_val1 = ac_val; |
2581 if (s->ac_pred) { | |
2582 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
|
2583 const int xy= s->mb_x-1 + s->mb_y*s->mb_stride; |
0 | 2584 /* left prediction */ |
2585 ac_val -= 16; | |
2967 | 2586 |
903 | 2587 if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){ |
575 | 2588 /* same qscale */ |
2589 for(i=1;i<8;i++) { | |
1092 | 2590 block[s->dsp.idct_permutation[i<<3]] += ac_val[i]; |
575 | 2591 } |
2592 }else{ | |
2593 /* different qscale, we must rescale */ | |
2594 for(i=1;i<8;i++) { | |
1092 | 2595 block[s->dsp.idct_permutation[i<<3]] += ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale); |
575 | 2596 } |
0 | 2597 } |
2598 } 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
|
2599 const int xy= s->mb_x + s->mb_y*s->mb_stride - s->mb_stride; |
0 | 2600 /* top prediction */ |
266 | 2601 ac_val -= 16 * s->block_wrap[n]; |
575 | 2602 |
903 | 2603 if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){ |
575 | 2604 /* same qscale */ |
2605 for(i=1;i<8;i++) { | |
1092 | 2606 block[s->dsp.idct_permutation[i]] += ac_val[i + 8]; |
575 | 2607 } |
2608 }else{ | |
2609 /* different qscale, we must rescale */ | |
2610 for(i=1;i<8;i++) { | |
1092 | 2611 block[s->dsp.idct_permutation[i]] += ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale); |
575 | 2612 } |
0 | 2613 } |
2614 } | |
2615 } | |
2616 /* left copy */ | |
2617 for(i=1;i<8;i++) | |
1092 | 2618 ac_val1[i ] = block[s->dsp.idct_permutation[i<<3]]; |
591 | 2619 |
0 | 2620 /* top copy */ |
2621 for(i=1;i<8;i++) | |
1092 | 2622 ac_val1[8 + i] = block[s->dsp.idct_permutation[i ]]; |
591 | 2623 |
0 | 2624 } |
2625 | |
8590 | 2626 #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
|
2627 |
1034 | 2628 /** |
2629 * encodes the dc value. | |
2630 * @param n block index (0-3 are luma, 4-5 are chroma) | |
2631 */ | |
453 | 2632 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
|
2633 { |
293 | 2634 #if 1 |
2635 level+=256; | |
2636 if (n < 4) { | |
2979 | 2637 /* luminance */ |
2638 put_bits(s, uni_DCtab_lum_len[level], uni_DCtab_lum_bits[level]); | |
293 | 2639 } else { |
2979 | 2640 /* chrominance */ |
2641 put_bits(s, uni_DCtab_chrom_len[level], uni_DCtab_chrom_bits[level]); | |
293 | 2642 } |
2643 #else | |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
2644 int size, v; |
0 | 2645 /* find number of bits */ |
2646 size = 0; | |
2647 v = abs(level); | |
2648 while (v) { | |
2979 | 2649 v >>= 1; |
2650 size++; | |
0 | 2651 } |
2652 | |
2653 if (n < 4) { | |
2979 | 2654 /* luminance */ |
2655 put_bits(&s->pb, DCtab_lum[size][1], DCtab_lum[size][0]); | |
0 | 2656 } else { |
2979 | 2657 /* chrominance */ |
2658 put_bits(&s->pb, DCtab_chrom[size][1], DCtab_chrom[size][0]); | |
0 | 2659 } |
2660 | |
2661 /* encode remaining bits */ | |
2662 if (size > 0) { | |
2979 | 2663 if (level < 0) |
2664 level = (-level) ^ ((1 << size) - 1); | |
2665 put_bits(&s->pb, size, level); | |
2666 if (size > 8) | |
2667 put_bits(&s->pb, 1, 1); | |
0 | 2668 } |
293 | 2669 #endif |
0 | 2670 } |
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
|
2671 |
2502 | 2672 static inline int mpeg4_get_dc_length(int level, int n){ |
2673 if (n < 4) { | |
2674 return uni_DCtab_lum_len[level + 256]; | |
2675 } else { | |
2676 return uni_DCtab_chrom_len[level + 256]; | |
2677 } | |
2678 } | |
2679 | |
1034 | 2680 /** |
2681 * encodes a 8x8 block | |
2682 * @param n block index (0-3 are luma, 4-5 are chroma) | |
2683 */ | |
2967 | 2684 static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n, int intra_dc, |
1064 | 2685 uint8_t *scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb) |
0 | 2686 { |
751 | 2687 int i, last_non_zero; |
2688 #if 0 //variables for the outcommented version | |
2689 int code, sign, last; | |
2690 #endif | |
0 | 2691 const RLTable *rl; |
1064 | 2692 uint32_t *bits_tab; |
2693 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
|
2694 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
|
2695 |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
2696 if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away |
2979 | 2697 /* mpeg4 based DC predictor */ |
2698 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
|
2699 if(last_index<1) return; |
2979 | 2700 i = 1; |
0 | 2701 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
|
2702 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
|
2703 len_tab = uni_mpeg4_intra_rl_len; |
0 | 2704 } 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
|
2705 if(last_index<0) return; |
2979 | 2706 i = 0; |
0 | 2707 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
|
2708 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
|
2709 len_tab = uni_mpeg4_inter_rl_len; |
0 | 2710 } |
2711 | |
2712 /* AC coefs */ | |
2713 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
|
2714 #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
|
2715 for (; i < last_index; i++) { |
2979 | 2716 int level = block[ scan_table[i] ]; |
2717 if (level) { | |
2718 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
|
2719 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
|
2720 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
|
2721 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
|
2722 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
|
2723 }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
|
2724 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
|
2725 } |
2979 | 2726 last_non_zero = i; |
2727 } | |
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
|
2728 } |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream 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(i<=last_index)*/{ |
2979 | 2730 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
|
2731 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
|
2732 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
|
2733 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
|
2734 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
|
2735 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
|
2736 }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
|
2737 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
|
2738 } |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream 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 } |
dddcff6841f2
optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents:
619
diff
changeset
|
2740 #else |
0 | 2741 for (; i <= last_index; i++) { |
2979 | 2742 const int slevel = block[ scan_table[i] ]; |
2743 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
|
2744 int level; |
2979 | 2745 int run = i - last_non_zero - 1; |
2746 last = (i == last_index); | |
2747 sign = 0; | |
2748 level = slevel; | |
2749 if (level < 0) { | |
2750 sign = 1; | |
2751 level = -level; | |
2752 } | |
0 | 2753 code = get_rl_index(rl, last, run, level); |
453 | 2754 put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]); |
0 | 2755 if (code == rl->n) { |
2756 int level1, run1; | |
2757 level1 = level - rl->max_level[last][run]; | |
2967 | 2758 if (level1 < 1) |
0 | 2759 goto esc2; |
2760 code = get_rl_index(rl, last, run, level1); | |
2761 if (code == rl->n) { | |
2762 esc2: | |
453 | 2763 put_bits(ac_pb, 1, 1); |
0 | 2764 if (level > MAX_LEVEL) |
2765 goto esc3; | |
2766 run1 = run - rl->max_run[last][level] - 1; | |
2767 if (run1 < 0) | |
2768 goto esc3; | |
2769 code = get_rl_index(rl, last, run1, level); | |
2770 if (code == rl->n) { | |
2771 esc3: | |
2772 /* third escape */ | |
453 | 2773 put_bits(ac_pb, 1, 1); |
2774 put_bits(ac_pb, 1, last); | |
2775 put_bits(ac_pb, 6, run); | |
2776 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
|
2777 put_sbits(ac_pb, 12, slevel); |
453 | 2778 put_bits(ac_pb, 1, 1); |
0 | 2779 } else { |
2780 /* second escape */ | |
453 | 2781 put_bits(ac_pb, 1, 0); |
2782 put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]); | |
2783 put_bits(ac_pb, 1, sign); | |
0 | 2784 } |
2785 } else { | |
2786 /* first escape */ | |
453 | 2787 put_bits(ac_pb, 1, 0); |
2788 put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]); | |
2789 put_bits(ac_pb, 1, sign); | |
0 | 2790 } |
2791 } else { | |
453 | 2792 put_bits(ac_pb, 1, sign); |
0 | 2793 } |
2979 | 2794 last_non_zero = i; |
2795 } | |
0 | 2796 } |
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
|
2797 #endif |
0 | 2798 } |
936 | 2799 |
2967 | 2800 static int mpeg4_get_block_length(MpegEncContext * s, DCTELEM * block, int n, int intra_dc, |
1064 | 2801 uint8_t *scan_table) |
936 | 2802 { |
2803 int i, last_non_zero; | |
1064 | 2804 uint8_t *len_tab; |
936 | 2805 const int last_index = s->block_last_index[n]; |
2806 int len=0; | |
2807 | |
2808 if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away | |
2979 | 2809 /* mpeg4 based DC predictor */ |
2810 len += mpeg4_get_dc_length(intra_dc, n); | |
936 | 2811 if(last_index<1) return len; |
2979 | 2812 i = 1; |
936 | 2813 len_tab = uni_mpeg4_intra_rl_len; |
2814 } else { | |
2815 if(last_index<0) return 0; | |
2979 | 2816 i = 0; |
936 | 2817 len_tab = uni_mpeg4_inter_rl_len; |
2818 } | |
2819 | |
2820 /* AC coefs */ | |
2821 last_non_zero = i - 1; | |
2822 for (; i < last_index; i++) { | |
2979 | 2823 int level = block[ scan_table[i] ]; |
2824 if (level) { | |
2825 int run = i - last_non_zero - 1; | |
936 | 2826 level+=64; |
2827 if((level&(~127)) == 0){ | |
2828 const int index= UNI_MPEG4_ENC_INDEX(0, run, level); | |
2829 len += len_tab[index]; | |
2830 }else{ //ESC3 | |
2831 len += 7+2+1+6+1+12+1; | |
2832 } | |
2979 | 2833 last_non_zero = i; |
2834 } | |
936 | 2835 } |
2836 /*if(i<=last_index)*/{ | |
2979 | 2837 int level = block[ scan_table[i] ]; |
936 | 2838 int run = i - last_non_zero - 1; |
2839 level+=64; | |
2840 if((level&(~127)) == 0){ | |
2841 const int index= UNI_MPEG4_ENC_INDEX(1, run, level); | |
2842 len += len_tab[index]; | |
2843 }else{ //ESC3 | |
2844 len += 7+2+1+6+1+12+1; | |
2845 } | |
2846 } | |
2967 | 2847 |
936 | 2848 return len; |
2849 } | |
2850 | |
815
78accc54493b
put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents:
770
diff
changeset
|
2851 #endif |
0 | 2852 |
2853 | |
2854 /***********************************************/ | |
2855 /* decoding */ | |
2856 | |
2857 static VLC intra_MCBPC_vlc; | |
2858 static VLC inter_MCBPC_vlc; | |
2859 static VLC cbpy_vlc; | |
2860 static VLC mv_vlc; | |
2861 static VLC dc_lum, dc_chrom; | |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
2862 static VLC sprite_trajectory; |
262 | 2863 static VLC mb_type_b_vlc; |
1655 | 2864 static VLC h263_mbtype_b_vlc; |
2865 static VLC cbpc_b_vlc; | |
0 | 2866 |
2867 /* init vlcs */ | |
2868 | |
2869 /* XXX: find a better solution to handle static init */ | |
2870 void h263_decode_init_vlc(MpegEncContext *s) | |
2871 { | |
2872 static int done = 0; | |
2873 | |
2874 if (!done) { | |
2875 done = 1; | |
2876 | |
7098 | 2877 INIT_VLC_STATIC(&intra_MCBPC_vlc, INTRA_MCBPC_VLC_BITS, 9, |
0 | 2878 intra_MCBPC_bits, 1, 1, |
7098 | 2879 intra_MCBPC_code, 1, 1, 72); |
2880 INIT_VLC_STATIC(&inter_MCBPC_vlc, INTER_MCBPC_VLC_BITS, 28, | |
0 | 2881 inter_MCBPC_bits, 1, 1, |
7098 | 2882 inter_MCBPC_code, 1, 1, 198); |
2883 INIT_VLC_STATIC(&cbpy_vlc, CBPY_VLC_BITS, 16, | |
0 | 2884 &cbpy_tab[0][1], 2, 1, |
7098 | 2885 &cbpy_tab[0][0], 2, 1, 64); |
2886 INIT_VLC_STATIC(&mv_vlc, MV_VLC_BITS, 33, | |
0 | 2887 &mvtab[0][1], 2, 1, |
7098 | 2888 &mvtab[0][0], 2, 1, 538); |
4668 | 2889 init_rl(&rl_inter, static_rl_table_store[0]); |
2890 init_rl(&rl_intra, static_rl_table_store[1]); | |
2891 init_rl(&rvlc_rl_inter, static_rl_table_store[3]); | |
2892 init_rl(&rvlc_rl_intra, static_rl_table_store[4]); | |
2893 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
|
2894 INIT_VLC_RL(rl_inter, 554); |
778ecab25dd8
Change init_vlc_rl() so it does not use *alloc_static() anymore.
michael
parents:
6918
diff
changeset
|
2895 INIT_VLC_RL(rl_intra, 554); |
778ecab25dd8
Change init_vlc_rl() so it does not use *alloc_static() anymore.
michael
parents:
6918
diff
changeset
|
2896 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
|
2897 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
|
2898 INIT_VLC_RL(rl_intra_aic, 554); |
7098 | 2899 INIT_VLC_STATIC(&dc_lum, DC_VLC_BITS, 10 /* 13 */, |
0 | 2900 &DCtab_lum[0][1], 2, 1, |
7098 | 2901 &DCtab_lum[0][0], 2, 1, 512); |
2902 INIT_VLC_STATIC(&dc_chrom, DC_VLC_BITS, 10 /* 13 */, | |
0 | 2903 &DCtab_chrom[0][1], 2, 1, |
7098 | 2904 &DCtab_chrom[0][0], 2, 1, 512); |
2905 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
|
2906 &sprite_trajectory_tab[0][1], 4, 2, |
7098 | 2907 &sprite_trajectory_tab[0][0], 4, 2, 128); |
2908 INIT_VLC_STATIC(&mb_type_b_vlc, MB_TYPE_B_VLC_BITS, 4, | |
262 | 2909 &mb_type_b_tab[0][1], 2, 1, |
7098 | 2910 &mb_type_b_tab[0][0], 2, 1, 16); |
2911 INIT_VLC_STATIC(&h263_mbtype_b_vlc, H263_MBTYPE_B_VLC_BITS, 15, | |
1655 | 2912 &h263_mbtype_b_tab[0][1], 2, 1, |
7098 | 2913 &h263_mbtype_b_tab[0][0], 2, 1, 80); |
2914 INIT_VLC_STATIC(&cbpc_b_vlc, CBPC_B_VLC_BITS, 4, | |
1655 | 2915 &cbpc_b_tab[0][1], 2, 1, |
7098 | 2916 &cbpc_b_tab[0][0], 2, 1, 8); |
0 | 2917 } |
2918 } | |
2919 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2920 /** |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2921 * 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
|
2922 */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2923 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
|
2924 if (s->height <= 400) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2925 return 1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2926 else if (s->height <= 800) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2927 return 2; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2928 else |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2929 return 4; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2930 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2931 |
1661 | 2932 int ff_h263_decode_mba(MpegEncContext *s) |
2933 { | |
2934 int i, mb_pos; | |
2935 | |
2936 for(i=0; i<6; i++){ | |
1670 | 2937 if(s->mb_num-1 <= ff_mba_max[i]) break; |
1661 | 2938 } |
2939 mb_pos= get_bits(&s->gb, ff_mba_length[i]); | |
2940 s->mb_x= mb_pos % s->mb_width; | |
2941 s->mb_y= mb_pos / s->mb_width; | |
2942 | |
2943 return mb_pos; | |
2944 } | |
2945 | |
2946 void ff_h263_encode_mba(MpegEncContext *s) | |
2947 { | |
2948 int i, mb_pos; | |
2949 | |
2950 for(i=0; i<6; i++){ | |
1670 | 2951 if(s->mb_num-1 <= ff_mba_max[i]) break; |
1661 | 2952 } |
2953 mb_pos= s->mb_x + s->mb_width*s->mb_y; | |
2954 put_bits(&s->pb, ff_mba_length[i], mb_pos); | |
2955 } | |
2956 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2957 /** |
1661 | 2958 * decodes the group of blocks header or slice header. |
6524 | 2959 * @return <0 if an error occurred |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2960 */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2961 static int h263_decode_gob_header(MpegEncContext *s) |
162 | 2962 { |
1661 | 2963 unsigned int val, gfid, gob_number; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2964 int left; |
2967 | 2965 |
162 | 2966 /* Check for GOB Start Code */ |
2967 val = show_bits(&s->gb, 16); | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2968 if(val) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2969 return -1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2970 |
162 | 2971 /* 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
|
2972 skip_bits(&s->gb, 16); /* Drop the zeros */ |
10535
95f3daa991a2
Use get_bits_left() instead of size_in_bits - get_bits_count().
rbultje
parents:
9999
diff
changeset
|
2973 left= get_bits_left(&s->gb); |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2974 //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
|
2975 for(;left>13; left--){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2976 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
|
2977 } |
2967 | 2978 if(left<=13) |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2979 return -1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
2980 |
1661 | 2981 if(s->h263_slice_structured){ |
2982 if(get_bits1(&s->gb)==0) | |
2983 return -1; | |
2984 | |
2985 ff_h263_decode_mba(s); | |
2986 | |
2987 if(s->mb_num > 1583) | |
2988 if(get_bits1(&s->gb)==0) | |
2989 return -1; | |
2967 | 2990 |
1661 | 2991 s->qscale = get_bits(&s->gb, 5); /* SQUANT */ |
2992 if(get_bits1(&s->gb)==0) | |
2993 return -1; | |
2994 gfid = get_bits(&s->gb, 2); /* GFID */ | |
2995 }else{ | |
2996 gob_number = get_bits(&s->gb, 5); /* GN */ | |
2997 s->mb_x= 0; | |
2998 s->mb_y= s->gob_index* gob_number; | |
2999 gfid = get_bits(&s->gb, 2); /* GFID */ | |
3000 s->qscale = get_bits(&s->gb, 5); /* GQUANT */ | |
3001 } | |
2967 | 3002 |
3003 if(s->mb_y >= s->mb_height) | |
1661 | 3004 return -1; |
3005 | |
2967 | 3006 if(s->qscale==0) |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3007 return -1; |
1644 | 3008 |
162 | 3009 return 0; |
3010 } | |
3011 | |
290 | 3012 static inline void memsetw(short *tab, int val, int n) |
3013 { | |
3014 int i; | |
3015 for(i=0;i<n;i++) | |
3016 tab[i] = val; | |
3017 } | |
3018 | |
8590 | 3019 #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
|
3020 |
453 | 3021 void ff_mpeg4_init_partitions(MpegEncContext *s) |
3022 { | |
9431 | 3023 uint8_t *start= put_bits_ptr(&s->pb); |
1799 | 3024 uint8_t *end= s->pb.buf_end; |
3025 int size= end - start; | |
9259 | 3026 int pb_size = (((intptr_t)start + size/3)&(~3)) - (intptr_t)start; |
1912 | 3027 int tex_size= (size - 2*pb_size)&(~3); |
2967 | 3028 |
1799 | 3029 set_put_bits_buffer_size(&s->pb, pb_size); |
3030 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
|
3031 init_put_bits(&s->pb2 , start + pb_size + tex_size, pb_size); |
453 | 3032 } |
3033 | |
3034 void ff_mpeg4_merge_partitions(MpegEncContext *s) | |
290 | 3035 { |
1786 | 3036 const int pb2_len = put_bits_count(&s->pb2 ); |
3037 const int tex_pb_len= put_bits_count(&s->tex_pb); | |
3038 const int bits= put_bits_count(&s->pb); | |
453 | 3039 |
6481 | 3040 if(s->pict_type==FF_I_TYPE){ |
453 | 3041 put_bits(&s->pb, 19, DC_MARKER); |
3042 s->misc_bits+=19 + pb2_len + bits - s->last_bits; | |
3043 s->i_tex_bits+= tex_pb_len; | |
3044 }else{ | |
3045 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
|
3046 s->misc_bits+=17 + pb2_len; |
453 | 3047 s->mv_bits+= bits - s->last_bits; |
3048 s->p_tex_bits+= tex_pb_len; | |
3049 } | |
3050 | |
3051 flush_put_bits(&s->pb2); | |
3052 flush_put_bits(&s->tex_pb); | |
3053 | |
1799 | 3054 set_put_bits_buffer_size(&s->pb, s->pb2.buf_end - s->pb.buf); |
3055 ff_copy_bits(&s->pb, s->pb2.buf , pb2_len); | |
3056 ff_copy_bits(&s->pb, s->tex_pb.buf, tex_pb_len); | |
1786 | 3057 s->last_bits= put_bits_count(&s->pb); |
453 | 3058 } |
3059 | |
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
|
3060 #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
|
3061 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3062 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
|
3063 switch(s->pict_type){ |
6481 | 3064 case FF_I_TYPE: |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3065 return 16; |
6481 | 3066 case FF_P_TYPE: |
3067 case FF_S_TYPE: | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3068 return s->f_code+15; |
6481 | 3069 case FF_B_TYPE: |
6655
22cca5d3173a
Implement FFMAX3(a,b,c) - maximum over three arguments.
voroshil
parents:
6524
diff
changeset
|
3070 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
|
3071 default: |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3072 return -1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3073 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3074 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3075 |
8590 | 3076 #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
|
3077 |
453 | 3078 void ff_mpeg4_encode_video_packet_header(MpegEncContext *s) |
3079 { | |
3080 int mb_num_bits= av_log2(s->mb_num - 1) + 1; | |
3081 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3082 put_bits(&s->pb, ff_mpeg4_get_video_packet_prefix_length(s), 0); |
453 | 3083 put_bits(&s->pb, 1, 1); |
2967 | 3084 |
453 | 3085 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
|
3086 put_bits(&s->pb, s->quant_precision, s->qscale); |
453 | 3087 put_bits(&s->pb, 1, 0); /* no HEC */ |
3088 } | |
3089 | |
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
|
3090 #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
|
3091 |
453 | 3092 /** |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3093 * 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
|
3094 * @return 0 if not |
453 | 3095 */ |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3096 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
|
3097 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
|
3098 int v= show_bits(&s->gb, 16); |
2967 | 3099 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3100 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
|
3101 return 0; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3102 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3103 |
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
|
3104 while(v<=0xFF){ |
6481 | 3105 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
|
3106 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
|
3107 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
|
3108 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
|
3109 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
|
3110 } |
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
|
3111 |
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
|
3112 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
|
3113 v>>=8; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3114 v|= 0x7F >> (7-(bits_count&7)); |
2967 | 3115 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3116 if(v==0x7F) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3117 return 1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3118 }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
|
3119 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
|
3120 int len; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3121 GetBitContext gb= s->gb; |
2967 | 3122 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3123 skip_bits(&s->gb, 1); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3124 align_get_bits(&s->gb); |
2967 | 3125 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3126 for(len=0; len<32; len++){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3127 if(get_bits1(&s->gb)) break; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3128 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3129 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3130 s->gb= gb; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3131 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3132 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
|
3133 return 1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3134 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3135 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3136 return 0; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3137 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3138 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3139 /** |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3140 * decodes the next video packet. |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3141 * @return <0 if something went wrong |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3142 */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3143 static int mpeg4_decode_video_packet_header(MpegEncContext *s) |
453 | 3144 { |
290 | 3145 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
|
3146 int header_extension=0, mb_num, len; |
2967 | 3147 |
453 | 3148 /* 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
|
3149 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
|
3150 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3151 for(len=0; len<32; len++){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3152 if(get_bits1(&s->gb)) break; |
453 | 3153 } |
3154 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3155 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
|
3156 av_log(s->avctx, AV_LOG_ERROR, "marker does not match f_code\n"); |
453 | 3157 return -1; |
3158 } | |
2967 | 3159 |
453 | 3160 if(s->shape != RECT_SHAPE){ |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3161 header_extension= get_bits1(&s->gb); |
453 | 3162 //FIXME more stuff here |
3163 } | |
3164 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3165 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
|
3166 if(mb_num>=s->mb_num){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
3167 av_log(s->avctx, AV_LOG_ERROR, "illegal mb_num in video packet (%d %d) \n", mb_num, s->mb_num); |
453 | 3168 return -1; |
3169 } | |
6481 | 3170 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
|
3171 while(s->next_picture.mbskip_table[ s->mb_index2xy[ mb_num ] ]) mb_num++; |
6497 | 3172 if(mb_num >= s->mb_num) return -1; // slice contains just skipped MBs which where already decoded |
1176 | 3173 } |
2967 | 3174 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3175 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
|
3176 s->mb_y= mb_num / s->mb_width; |
453 | 3177 |
3178 if(s->shape != BIN_ONLY_SHAPE){ | |
2967 | 3179 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
|
3180 if(qscale) |
1644 | 3181 s->chroma_qscale=s->qscale= qscale; |
290 | 3182 } |
3183 | |
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); |
290 | 3186 } |
3187 if(header_extension){ | |
453 | 3188 int time_increment; |
290 | 3189 int time_incr=0; |
453 | 3190 |
2967 | 3191 while (get_bits1(&s->gb) != 0) |
290 | 3192 time_incr++; |
3193 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3194 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
|
3195 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
|
3196 check_marker(&s->gb, "before vop_coding_type in video packed header"); |
2967 | 3197 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3198 skip_bits(&s->gb, 2); /* vop coding type */ |
290 | 3199 //FIXME not rect stuff here |
3200 | |
3201 if(s->shape != BIN_ONLY_SHAPE){ | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3202 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
|
3203 //FIXME don't just ignore everything |
6481 | 3204 if(s->pict_type == FF_S_TYPE && s->vol_sprite_usage==GMC_SPRITE){ |
1914 | 3205 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
|
3206 av_log(s->avctx, AV_LOG_ERROR, "untested\n"); |
290 | 3207 } |
3208 | |
3209 //FIXME reduced res stuff here | |
2967 | 3210 |
6481 | 3211 if (s->pict_type != FF_I_TYPE) { |
2979 | 3212 int f_code = get_bits(&s->gb, 3); /* fcode_for */ |
660 | 3213 if(f_code==0){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
3214 av_log(s->avctx, AV_LOG_ERROR, "Error, video packet header damaged (f_code=0)\n"); |
290 | 3215 } |
3216 } | |
6481 | 3217 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
|
3218 int b_code = get_bits(&s->gb, 3); |
660 | 3219 if(b_code==0){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
3220 av_log(s->avctx, AV_LOG_ERROR, "Error, video packet header damaged (b_code=0)\n"); |
660 | 3221 } |
2967 | 3222 } |
290 | 3223 } |
3224 } | |
3225 //FIXME new-pred stuff | |
2967 | 3226 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3227 return 0; |
453 | 3228 } |
3229 | |
3230 void ff_mpeg4_clean_buffers(MpegEncContext *s) | |
3231 { | |
3232 int c_wrap, c_xy, l_wrap, l_xy; | |
290 | 3233 |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
3234 l_wrap= s->b8_stride; |
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
3235 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
|
3236 c_wrap= s->mb_stride; |
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
3237 c_xy= (s->mb_y-1)*c_wrap + s->mb_x - 1; |
290 | 3238 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3239 #if 0 |
290 | 3240 /* clean DC */ |
453 | 3241 memsetw(s->dc_val[0] + l_xy, 1024, l_wrap*2+1); |
3242 memsetw(s->dc_val[1] + c_xy, 1024, c_wrap+1); | |
3243 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
|
3244 #endif |
290 | 3245 |
3246 /* clean AC */ | |
1064 | 3247 memset(s->ac_val[0] + l_xy, 0, (l_wrap*2+1)*16*sizeof(int16_t)); |
3248 memset(s->ac_val[1] + c_xy, 0, (c_wrap +1)*16*sizeof(int16_t)); | |
3249 memset(s->ac_val[2] + c_xy, 0, (c_wrap +1)*16*sizeof(int16_t)); | |
290 | 3250 |
3251 /* clean MV */ | |
2646
c735e3e60ca7
Even More spelling errors. patch by (Kevin Baragona <kevinmb500 gawab com)
michael
parents:
2639
diff
changeset
|
3252 // we can't clear the MVs as they might be needed by a b frame |
1064 | 3253 // memset(s->motion_val + l_xy, 0, (l_wrap*2+1)*2*sizeof(int16_t)); |
3254 // memset(s->motion_val, 0, 2*sizeof(int16_t)*(2 + s->mb_width*2)*(2 + s->mb_height*2)); | |
453 | 3255 s->last_mv[0][0][0]= |
3256 s->last_mv[0][0][1]= | |
3257 s->last_mv[1][0][0]= | |
3258 s->last_mv[1][0][1]= 0; | |
3259 } | |
3260 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3261 /** |
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
|
3262 * 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
|
3263 * @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
|
3264 * @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
|
3265 * @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
|
3266 */ |
2bf694251330
Add ff_h263_find_resync_marker() to find the bit position of the next resync_marker, if any.
michael
parents:
9008
diff
changeset
|
3267 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
|
3268 { |
2bf694251330
Add ff_h263_find_resync_marker() to find the bit position of the next resync_marker, if any.
michael
parents:
9008
diff
changeset
|
3269 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
|
3270 |
2bf694251330
Add ff_h263_find_resync_marker() to find the bit position of the next resync_marker, if any.
michael
parents:
9008
diff
changeset
|
3271 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
|
3272 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
|
3273 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
|
3274 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
|
3275 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
|
3276 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
|
3277 } |
2bf694251330
Add ff_h263_find_resync_marker() to find the bit position of the next resync_marker, if any.
michael
parents:
9008
diff
changeset
|
3278 } |
2bf694251330
Add ff_h263_find_resync_marker() to find the bit position of the next resync_marker, if any.
michael
parents:
9008
diff
changeset
|
3279 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
|
3280 } |
2bf694251330
Add ff_h263_find_resync_marker() to find the bit position of the next resync_marker, if any.
michael
parents:
9008
diff
changeset
|
3281 |
2bf694251330
Add ff_h263_find_resync_marker() to find the bit position of the next resync_marker, if any.
michael
parents:
9008
diff
changeset
|
3282 /** |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3283 * 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
|
3284 * @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
|
3285 */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3286 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
|
3287 int left, pos, ret; |
2967 | 3288 |
1521 | 3289 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
|
3290 skip_bits1(&s->gb); |
1521 | 3291 align_get_bits(&s->gb); |
3292 } | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3293 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3294 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
|
3295 pos= get_bits_count(&s->gb); |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3296 if(s->codec_id==CODEC_ID_MPEG4) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3297 ret= mpeg4_decode_video_packet_header(s); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3298 else |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3299 ret= h263_decode_gob_header(s); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3300 if(ret>=0) |
8691
25aa5388fa97
Make ff_h263_resync() return the bit position of the resync_marker or
benoit
parents:
8690
diff
changeset
|
3301 return pos; |
453 | 3302 } |
5129 | 3303 //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
|
3304 s->gb= s->last_resync_gb; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3305 align_get_bits(&s->gb); |
10535
95f3daa991a2
Use get_bits_left() instead of size_in_bits - get_bits_count().
rbultje
parents:
9999
diff
changeset
|
3306 left= get_bits_left(&s->gb); |
2967 | 3307 |
3308 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
|
3309 if(show_bits(&s->gb, 16)==0){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3310 GetBitContext bak= s->gb; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3311 |
8691
25aa5388fa97
Make ff_h263_resync() return the bit position of the resync_marker or
benoit
parents:
8690
diff
changeset
|
3312 pos= get_bits_count(&s->gb); |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3313 if(s->codec_id==CODEC_ID_MPEG4) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3314 ret= mpeg4_decode_video_packet_header(s); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3315 else |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3316 ret= h263_decode_gob_header(s); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3317 if(ret>=0) |
8691
25aa5388fa97
Make ff_h263_resync() return the bit position of the resync_marker or
benoit
parents:
8690
diff
changeset
|
3318 return pos; |
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 s->gb= bak; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3321 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3322 skip_bits(&s->gb, 8); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3323 } |
2967 | 3324 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3325 return -1; |
453 | 3326 } |
3327 | |
3328 /** | |
1034 | 3329 * gets the average motion vector for a GMC MB. |
753 | 3330 * @param n either 0 for the x component or 1 for y |
3331 * @returns the average MV for a GMC MB | |
3332 */ | |
3333 static inline int get_amv(MpegEncContext *s, int n){ | |
3334 int x, y, mb_v, sum, dx, dy, shift; | |
3335 int len = 1 << (s->f_code + 4); | |
3336 const int a= s->sprite_warping_accuracy; | |
2967 | 3337 |
1997 | 3338 if(s->workaround_bugs & FF_BUG_AMV) |
3339 len >>= s->quarter_sample; | |
753 | 3340 |
3341 if(s->real_sprite_warping_points==1){ | |
3342 if(s->divx_version==500 && s->divx_build==413) | |
3343 sum= s->sprite_offset[0][n] / (1<<(a - s->quarter_sample)); | |
3344 else | |
3345 sum= RSHIFT(s->sprite_offset[0][n]<<s->quarter_sample, a); | |
3346 }else{ | |
3347 dx= s->sprite_delta[n][0]; | |
3348 dy= s->sprite_delta[n][1]; | |
3349 shift= s->sprite_shift[0]; | |
3350 if(n) dy -= 1<<(shift + a + 1); | |
3351 else dx -= 1<<(shift + a + 1); | |
3352 mb_v= s->sprite_offset[0][n] + dx*s->mb_x*16 + dy*s->mb_y*16; | |
3353 | |
3354 sum=0; | |
3355 for(y=0; y<16; y++){ | |
3356 int v; | |
2967 | 3357 |
753 | 3358 v= mb_v + dy*y; |
3359 //XXX FIXME optimize | |
3360 for(x=0; x<16; x++){ | |
3361 sum+= v>>shift; | |
3362 v+= dx; | |
3363 } | |
3364 } | |
999
74dc4105e147
average motion vector rounding like the reference says and not what the standard says
michaelni
parents:
953
diff
changeset
|
3365 sum= RSHIFT(sum, a+8-s->quarter_sample); |
753 | 3366 } |
3367 | |
3368 if (sum < -len) sum= -len; | |
3369 else if (sum >= len) sum= len-1; | |
3370 | |
3371 return sum; | |
3372 } | |
3373 | |
3374 /** | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3375 * decodes first partition. |
6524 | 3376 * @return number of MBs decoded or <0 if an error occurred |
453 | 3377 */ |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3378 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
|
3379 int mb_num; |
1064 | 3380 static const int8_t quant_tab[4] = { -1, -2, 1, 2 }; |
2967 | 3381 |
453 | 3382 /* decode first partition */ |
3383 mb_num=0; | |
290 | 3384 s->first_slice_line=1; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3385 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
|
3386 ff_init_block_index(s); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3387 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
|
3388 const int xy= s->mb_x + s->mb_y*s->mb_stride; |
453 | 3389 int cbpc; |
3390 int dir=0; | |
2967 | 3391 |
453 | 3392 mb_num++; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3393 ff_update_block_index(s); |
453 | 3394 if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1) |
3395 s->first_slice_line=0; | |
2967 | 3396 |
6481 | 3397 if(s->pict_type==FF_I_TYPE){ |
453 | 3398 int i; |
3399 | |
1482 | 3400 do{ |
1873 | 3401 if(show_bits_long(&s->gb, 19)==DC_MARKER){ |
3402 return mb_num-1; | |
3403 } | |
3404 | |
1482 | 3405 cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2); |
3406 if (cbpc < 0){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
3407 av_log(s->avctx, AV_LOG_ERROR, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y); |
1482 | 3408 return -1; |
3409 } | |
3410 }while(cbpc == 8); | |
2967 | 3411 |
453 | 3412 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
|
3413 s->current_picture.mb_type[xy]= MB_TYPE_INTRA; |
453 | 3414 s->mb_intra = 1; |
3415 | |
3416 if(cbpc & 4) { | |
1652 | 3417 ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]); |
453 | 3418 } |
903 | 3419 s->current_picture.qscale_table[xy]= s->qscale; |
453 | 3420 |
3421 s->mbintra_table[xy]= 1; | |
3422 for(i=0; i<6; i++){ | |
3423 int dc_pred_dir; | |
2967 | 3424 int dc= mpeg4_decode_dc(s, i, &dc_pred_dir); |
453 | 3425 if(dc < 0){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
3426 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
|
3427 return -1; |
453 | 3428 } |
3429 dir<<=1; | |
3430 if(dc_pred_dir) dir|=1; | |
3431 } | |
3432 s->pred_dir_table[xy]= dir; | |
3433 }else{ /* P/S_TYPE */ | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3434 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
|
3435 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
|
3436 const int stride= s->b8_stride*2; |
453 | 3437 |
1873 | 3438 try_again: |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3439 bits= show_bits(&s->gb, 17); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3440 if(bits==MOTION_MARKER){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3441 return mb_num-1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3442 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3443 skip_bits1(&s->gb); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3444 if(bits&0x10000){ |
453 | 3445 /* skip mb */ |
6481 | 3446 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
|
3447 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0; |
753 | 3448 mx= get_amv(s, 0); |
3449 my= get_amv(s, 1); | |
453 | 3450 }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
|
3451 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0; |
753 | 3452 mx=my=0; |
453 | 3453 } |
3454 mot_val[0 ]= mot_val[2 ]= | |
3455 mot_val[0+stride]= mot_val[2+stride]= mx; | |
3456 mot_val[1 ]= mot_val[3 ]= | |
3457 mot_val[1+stride]= mot_val[3+stride]= my; | |
3458 | |
3459 if(s->mbintra_table[xy]) | |
3460 ff_clean_intra_table_entries(s); | |
3461 continue; | |
3462 } | |
1482 | 3463 |
544 | 3464 cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2); |
453 | 3465 if (cbpc < 0){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
3466 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
|
3467 return -1; |
453 | 3468 } |
1873 | 3469 if(cbpc == 20) |
3470 goto try_again; | |
1482 | 3471 |
453 | 3472 s->cbp_table[xy]= cbpc&(8+3); //8 is dquant |
2967 | 3473 |
453 | 3474 s->mb_intra = ((cbpc & 4) != 0); |
2967 | 3475 |
453 | 3476 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
|
3477 s->current_picture.mb_type[xy]= MB_TYPE_INTRA; |
453 | 3478 s->mbintra_table[xy]= 1; |
2967 | 3479 mot_val[0 ]= mot_val[2 ]= |
453 | 3480 mot_val[0+stride]= mot_val[2+stride]= 0; |
3481 mot_val[1 ]= mot_val[3 ]= | |
3482 mot_val[1+stride]= mot_val[3+stride]= 0; | |
3483 }else{ | |
3484 if(s->mbintra_table[xy]) | |
3485 ff_clean_intra_table_entries(s); | |
3486 | |
6481 | 3487 if(s->pict_type==FF_S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0) |
453 | 3488 s->mcsel= get_bits1(&s->gb); |
3489 else s->mcsel= 0; | |
2967 | 3490 |
453 | 3491 if ((cbpc & 16) == 0) { |
3492 /* 16x16 motion prediction */ | |
3493 | |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
3494 h263_pred_motion(s, 0, 0, &pred_x, &pred_y); |
753 | 3495 if(!s->mcsel){ |
3496 mx = h263_decode_motion(s, pred_x, s->f_code); | |
3497 if (mx >= 0xffff) | |
3498 return -1; | |
3499 | |
3500 my = h263_decode_motion(s, pred_y, s->f_code); | |
3501 if (my >= 0xffff) | |
3502 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
|
3503 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0; |
753 | 3504 } else { |
3505 mx = get_amv(s, 0); | |
3506 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
|
3507 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0; |
453 | 3508 } |
753 | 3509 |
453 | 3510 mot_val[0 ]= mot_val[2 ] = |
3511 mot_val[0+stride]= mot_val[2+stride]= mx; | |
3512 mot_val[1 ]= mot_val[3 ]= | |
3513 mot_val[1+stride]= mot_val[3+stride]= my; | |
3514 } else { | |
3515 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
|
3516 s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0; |
453 | 3517 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
|
3518 int16_t *mot_val= h263_pred_motion(s, i, 0, &pred_x, &pred_y); |
453 | 3519 mx = h263_decode_motion(s, pred_x, s->f_code); |
3520 if (mx >= 0xffff) | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3521 return -1; |
2967 | 3522 |
453 | 3523 my = h263_decode_motion(s, pred_y, s->f_code); |
3524 if (my >= 0xffff) | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3525 return -1; |
453 | 3526 mot_val[0] = mx; |
3527 mot_val[1] = my; | |
3528 } | |
3529 } | |
3530 } | |
3531 } | |
3532 } | |
3533 s->mb_x= 0; | |
3534 } | |
3535 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3536 return mb_num; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3537 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3538 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3539 /** |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3540 * decode second partition. |
6524 | 3541 * @return <0 if an error occurred |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3542 */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3543 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
|
3544 int mb_num=0; |
1064 | 3545 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
|
3546 |
453 | 3547 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
|
3548 s->first_slice_line=1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3549 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
|
3550 ff_init_block_index(s); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3551 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
|
3552 const int xy= s->mb_x + s->mb_y*s->mb_stride; |
453 | 3553 |
3554 mb_num++; | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3555 ff_update_block_index(s); |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3556 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
|
3557 s->first_slice_line=0; |
2967 | 3558 |
6481 | 3559 if(s->pict_type==FF_I_TYPE){ |
453 | 3560 int ac_pred= get_bits1(&s->gb); |
544 | 3561 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1); |
453 | 3562 if(cbpy<0){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
3563 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
|
3564 return -1; |
453 | 3565 } |
2967 | 3566 |
453 | 3567 s->cbp_table[xy]|= cbpy<<2; |
2967 | 3568 s->current_picture.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED; |
453 | 3569 }else{ /* P || S_TYPE */ |
2967 | 3570 if(IS_INTRA(s->current_picture.mb_type[xy])){ |
453 | 3571 int dir=0,i; |
3572 int ac_pred = get_bits1(&s->gb); | |
544 | 3573 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1); |
453 | 3574 |
3575 if(cbpy<0){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
3576 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
|
3577 return -1; |
453 | 3578 } |
2967 | 3579 |
453 | 3580 if(s->cbp_table[xy] & 8) { |
1652 | 3581 ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]); |
453 | 3582 } |
903 | 3583 s->current_picture.qscale_table[xy]= s->qscale; |
453 | 3584 |
3585 for(i=0; i<6; i++){ | |
3586 int dc_pred_dir; | |
2967 | 3587 int dc= mpeg4_decode_dc(s, i, &dc_pred_dir); |
453 | 3588 if(dc < 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, "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
|
3590 return -1; |
453 | 3591 } |
3592 dir<<=1; | |
3593 if(dc_pred_dir) dir|=1; | |
3594 } | |
3595 s->cbp_table[xy]&= 3; //remove dquant | |
3596 s->cbp_table[xy]|= cbpy<<2; | |
2967 | 3597 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
|
3598 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
|
3599 }else if(IS_SKIP(s->current_picture.mb_type[xy])){ |
903 | 3600 s->current_picture.qscale_table[xy]= s->qscale; |
453 | 3601 s->cbp_table[xy]= 0; |
3602 }else{ | |
544 | 3603 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1); |
453 | 3604 |
3605 if(cbpy<0){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
3606 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
|
3607 return -1; |
453 | 3608 } |
2967 | 3609 |
453 | 3610 if(s->cbp_table[xy] & 8) { |
1652 | 3611 ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]); |
453 | 3612 } |
903 | 3613 s->current_picture.qscale_table[xy]= s->qscale; |
453 | 3614 |
3615 s->cbp_table[xy]&= 3; //remove dquant | |
3616 s->cbp_table[xy]|= (cbpy^0xf)<<2; | |
3617 } | |
3618 } | |
3619 } | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3620 if(mb_num >= mb_count) return 0; |
453 | 3621 s->mb_x= 0; |
3622 } | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3623 return 0; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3624 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3625 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3626 /** |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3627 * decodes the first & second partition |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3628 * @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
|
3629 */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3630 int ff_mpeg4_decode_partitions(MpegEncContext *s) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3631 { |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3632 int mb_num; |
6481 | 3633 const int part_a_error= s->pict_type==FF_I_TYPE ? (DC_ERROR|MV_ERROR) : MV_ERROR; |
3634 const int part_a_end = s->pict_type==FF_I_TYPE ? (DC_END |MV_END) : MV_END; | |
2967 | 3635 |
3636 mb_num= mpeg4_decode_partition_a(s); | |
1144 | 3637 if(mb_num<0){ |
3638 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
|
3639 return -1; |
1144 | 3640 } |
2967 | 3641 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3642 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
|
3643 av_log(s->avctx, AV_LOG_ERROR, "slice below monitor ...\n"); |
1144 | 3644 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
|
3645 return -1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3646 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3647 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3648 s->mb_num_left= mb_num; |
2967 | 3649 |
6481 | 3650 if(s->pict_type==FF_I_TYPE){ |
1873 | 3651 while(show_bits(&s->gb, 9) == 1) |
3652 skip_bits(&s->gb, 9); | |
1257 | 3653 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
|
3654 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
|
3655 return -1; |
1144 | 3656 } |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3657 }else{ |
1873 | 3658 while(show_bits(&s->gb, 10) == 1) |
3659 skip_bits(&s->gb, 10); | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3660 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
|
3661 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
|
3662 return -1; |
1144 | 3663 } |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3664 } |
1144 | 3665 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, part_a_end); |
2967 | 3666 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3667 if( mpeg4_decode_partition_b(s, mb_num) < 0){ |
6481 | 3668 if(s->pict_type==FF_P_TYPE) |
1144 | 3669 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
|
3670 return -1; |
1144 | 3671 }else{ |
6481 | 3672 if(s->pict_type==FF_P_TYPE) |
1144 | 3673 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
|
3674 } |
453 | 3675 |
2967 | 3676 return 0; |
453 | 3677 } |
3678 | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3679 /** |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3680 * decode partition C of one MB. |
6524 | 3681 * @return <0 if an error occurred |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3682 */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3683 static int mpeg4_decode_partitioned_mb(MpegEncContext *s, DCTELEM block[6][64]) |
453 | 3684 { |
3685 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
|
3686 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
|
3687 |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3688 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
|
3689 cbp = s->cbp_table[xy]; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3690 |
3282 | 3691 s->use_intra_dc_vlc= s->qscale < s->intra_dc_threshold; |
3692 | |
903 | 3693 if(s->current_picture.qscale_table[xy] != s->qscale){ |
1652 | 3694 ff_set_qscale(s, s->current_picture.qscale_table[xy] ); |
453 | 3695 } |
2967 | 3696 |
6481 | 3697 if (s->pict_type == FF_P_TYPE || s->pict_type==FF_S_TYPE) { |
453 | 3698 int i; |
3699 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
|
3700 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
|
3701 s->mv[0][i][1] = s->current_picture.motion_val[0][ s->block_index[i] ][1]; |
453 | 3702 } |
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
|
3703 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
|
3704 |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
3705 if (IS_SKIP(mb_type)) { |
453 | 3706 /* skip mb */ |
3707 for(i=0;i<6;i++) | |
3708 s->block_last_index[i] = -1; | |
3709 s->mv_dir = MV_DIR_FORWARD; | |
3710 s->mv_type = MV_TYPE_16X16; | |
6481 | 3711 if(s->pict_type==FF_S_TYPE && s->vol_sprite_usage==GMC_SPRITE){ |
453 | 3712 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
|
3713 s->mb_skipped = 0; |
453 | 3714 }else{ |
3715 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
|
3716 s->mb_skipped = 1; |
453 | 3717 } |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3718 }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
|
3719 s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]); |
453 | 3720 }else if(!s->mb_intra){ |
3721 // s->mcsel= 0; //FIXME do we need to init that | |
2967 | 3722 |
453 | 3723 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
|
3724 if (IS_8X8(mb_type)) { |
453 | 3725 s->mv_type = MV_TYPE_8X8; |
3726 } else { | |
3727 s->mv_type = MV_TYPE_16X16; | |
3728 } | |
3729 } | |
3730 } else { /* I-Frame */ | |
3731 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
|
3732 s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]); |
1132 | 3733 } |
3734 | |
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
|
3735 if (!IS_SKIP(mb_type)) { |
1132 | 3736 int i; |
2632 | 3737 s->dsp.clear_blocks(s->block[0]); |
453 | 3738 /* decode each block */ |
3739 for (i = 0; i < 6; i++) { | |
1132 | 3740 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
|
3741 av_log(s->avctx, AV_LOG_ERROR, "texture corrupted at %d %d %d\n", s->mb_x, s->mb_y, s->mb_intra); |
453 | 3742 return -1; |
3743 } | |
718 | 3744 cbp+=cbp; |
453 | 3745 } |
3746 } | |
290 | 3747 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3748 /* per-MB end of slice check */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3749 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3750 if(--s->mb_num_left <= 0){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3751 if(mpeg4_is_resync(s)) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3752 return SLICE_END; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3753 else |
2967 | 3754 return SLICE_NOEND; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3755 }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
|
3756 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
|
3757 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
|
3758 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
|
3759 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
|
3760 } |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead 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 return SLICE_OK; |
619
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3762 } |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
3763 } |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3764 |
1633 | 3765 /** |
3766 * read the next MVs for OBMC. yes this is a ugly hack, feel free to send a patch :) | |
3767 */ | |
3768 static void preview_obmc(MpegEncContext *s){ | |
3769 GetBitContext gb= s->gb; | |
2967 | 3770 |
1633 | 3771 int cbpc, i, pred_x, pred_y, mx, my; |
3772 int16_t *mot_val; | |
3773 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
|
3774 const int stride= s->b8_stride*2; |
2967 | 3775 |
1633 | 3776 for(i=0; i<4; i++) |
3777 s->block_index[i]+= 2; | |
3778 for(i=4; i<6; i++) | |
3779 s->block_index[i]+= 1; | |
3780 s->mb_x++; | |
2967 | 3781 |
6481 | 3782 assert(s->pict_type == FF_P_TYPE); |
1633 | 3783 |
3784 do{ | |
3785 if (get_bits1(&s->gb)) { | |
3786 /* 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
|
3787 mot_val = s->current_picture.motion_val[0][ s->block_index[0] ]; |
2967 | 3788 mot_val[0 ]= mot_val[2 ]= |
1633 | 3789 mot_val[0+stride]= mot_val[2+stride]= 0; |
3790 mot_val[1 ]= mot_val[3 ]= | |
3791 mot_val[1+stride]= mot_val[3+stride]= 0; | |
2967 | 3792 |
1633 | 3793 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0; |
3794 goto end; | |
3795 } | |
3796 cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2); | |
3797 }while(cbpc == 20); | |
2967 | 3798 |
1633 | 3799 if(cbpc & 4){ |
3800 s->current_picture.mb_type[xy]= MB_TYPE_INTRA; | |
3801 }else{ | |
3802 get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1); | |
3803 if (cbpc & 8) { | |
1656 | 3804 if(s->modified_quant){ |
3805 if(get_bits1(&s->gb)) skip_bits(&s->gb, 1); | |
3806 else skip_bits(&s->gb, 5); | |
3807 }else | |
3808 skip_bits(&s->gb, 2); | |
1633 | 3809 } |
2967 | 3810 |
1633 | 3811 if ((cbpc & 16) == 0) { |
2967 | 3812 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0; |
1633 | 3813 /* 16x16 motion prediction */ |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
3814 mot_val= h263_pred_motion(s, 0, 0, &pred_x, &pred_y); |
1633 | 3815 if (s->umvplus) |
3816 mx = h263p_decode_umotion(s, pred_x); | |
3817 else | |
1655 | 3818 mx = h263_decode_motion(s, pred_x, 1); |
2967 | 3819 |
1633 | 3820 if (s->umvplus) |
3821 my = h263p_decode_umotion(s, pred_y); | |
3822 else | |
1655 | 3823 my = h263_decode_motion(s, pred_y, 1); |
2967 | 3824 |
3825 mot_val[0 ]= mot_val[2 ]= | |
1633 | 3826 mot_val[0+stride]= mot_val[2+stride]= mx; |
3827 mot_val[1 ]= mot_val[3 ]= | |
3828 mot_val[1+stride]= mot_val[3+stride]= my; | |
3829 } else { | |
2967 | 3830 s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0; |
1633 | 3831 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
|
3832 mot_val = h263_pred_motion(s, i, 0, &pred_x, &pred_y); |
1633 | 3833 if (s->umvplus) |
3834 mx = h263p_decode_umotion(s, pred_x); | |
3835 else | |
1655 | 3836 mx = h263_decode_motion(s, pred_x, 1); |
2967 | 3837 |
1633 | 3838 if (s->umvplus) |
3839 my = h263p_decode_umotion(s, pred_y); | |
2967 | 3840 else |
1655 | 3841 my = h263_decode_motion(s, pred_y, 1); |
1633 | 3842 if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1) |
3843 skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */ | |
3844 mot_val[0] = mx; | |
3845 mot_val[1] = my; | |
3846 } | |
3847 } | |
3848 } | |
3849 end: | |
2967 | 3850 |
1633 | 3851 for(i=0; i<4; i++) |
3852 s->block_index[i]-= 2; | |
3853 for(i=4; i<6; i++) | |
3854 s->block_index[i]-= 1; | |
3855 s->mb_x--; | |
3856 | |
3857 s->gb= gb; | |
3858 } | |
3859 | |
1656 | 3860 static void h263_decode_dquant(MpegEncContext *s){ |
3861 static const int8_t quant_tab[4] = { -1, -2, 1, 2 }; | |
3862 | |
3863 if(s->modified_quant){ | |
3864 if(get_bits1(&s->gb)) | |
3865 s->qscale= modified_quant_tab[get_bits1(&s->gb)][ s->qscale ]; | |
3866 else | |
3867 s->qscale= get_bits(&s->gb, 5); | |
3868 }else | |
3869 s->qscale += quant_tab[get_bits(&s->gb, 2)]; | |
3870 ff_set_qscale(s, s->qscale); | |
3871 } | |
3872 | |
9103
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
3873 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
|
3874 { |
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
3875 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
|
3876 int i, mbi; |
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
3877 |
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
3878 /* 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
|
3879 * 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
|
3880 */ |
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
3881 mbi = s->mb_intra; |
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
3882 s->mb_intra = 0; |
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
3883 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
|
3884 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
|
3885 return -1; |
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
3886 cbp+=cbp; |
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
3887 } |
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
3888 s->mb_intra = mbi; |
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
3889 return 0; |
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
3890 } |
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
3891 |
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
3892 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
|
3893 { |
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
3894 int c, mv = 1; |
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
3895 |
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
3896 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
|
3897 c = get_bits1(gb); |
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
3898 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
|
3899 mv = !get_bits1(gb); |
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
3900 } 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
|
3901 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
|
3902 c = mv & 1; |
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
3903 mv = !!(mv & 2); |
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 if(c) |
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
3906 *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
|
3907 return mv; |
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
3908 } |
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
3909 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3910 int ff_h263_decode_mb(MpegEncContext *s, |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
3911 DCTELEM block[6][64]) |
0 | 3912 { |
3913 int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant; | |
1064 | 3914 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
|
3915 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
|
3916 int cbpb = 0, pb_mv_count = 0; |
2967 | 3917 |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3918 assert(!s->h263_pred); |
2967 | 3919 |
6481 | 3920 if (s->pict_type == FF_P_TYPE) { |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3921 do{ |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3922 if (get_bits1(&s->gb)) { |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3923 /* skip mb */ |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3924 s->mb_intra = 0; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3925 for(i=0;i<6;i++) |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3926 s->block_last_index[i] = -1; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3927 s->mv_dir = MV_DIR_FORWARD; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3928 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
|
3929 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0; |
255 | 3930 s->mv[0][0][0] = 0; |
3931 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
|
3932 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
|
3933 goto end; |
255 | 3934 } |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3935 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
|
3936 if (cbpc < 0){ |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3937 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
|
3938 return -1; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3939 } |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3940 }while(cbpc == 20); |
2967 | 3941 |
2632 | 3942 s->dsp.clear_blocks(s->block[0]); |
2967 | 3943 |
0 | 3944 dquant = cbpc & 8; |
3945 s->mb_intra = ((cbpc & 4) != 0); | |
262 | 3946 if (s->mb_intra) goto intra; |
2967 | 3947 |
9103
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
3948 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
|
3949 pb_mv_count = h263_get_modb(&s->gb, s->pb_frame, &cbpb); |
544 | 3950 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1); |
2967 | 3951 |
1637 | 3952 if(s->alt_inter_vlc==0 || (cbpc & 3)!=3) |
3953 cbpy ^= 0xF; | |
2967 | 3954 |
1637 | 3955 cbp = (cbpc & 3) | (cbpy << 2); |
0 | 3956 if (dquant) { |
1656 | 3957 h263_decode_dquant(s); |
0 | 3958 } |
2967 | 3959 |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3960 s->mv_dir = MV_DIR_FORWARD; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3961 if ((cbpc & 16) == 0) { |
2967 | 3962 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
|
3963 /* 16x16 motion prediction */ |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3964 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
|
3965 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
|
3966 if (s->umvplus) |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3967 mx = h263p_decode_umotion(s, pred_x); |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3968 else |
1655 | 3969 mx = h263_decode_motion(s, pred_x, 1); |
2967 | 3970 |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3971 if (mx >= 0xffff) |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3972 return -1; |
2967 | 3973 |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3974 if (s->umvplus) |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3975 my = h263p_decode_umotion(s, pred_y); |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3976 else |
1655 | 3977 my = h263_decode_motion(s, pred_y, 1); |
2967 | 3978 |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3979 if (my >= 0xffff) |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3980 return -1; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3981 s->mv[0][0][0] = mx; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3982 s->mv[0][0][1] = my; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3983 |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3984 if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1) |
2967 | 3985 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
|
3986 } else { |
2967 | 3987 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
|
3988 s->mv_type = MV_TYPE_8X8; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3989 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
|
3990 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
|
3991 if (s->umvplus) |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3992 mx = h263p_decode_umotion(s, pred_x); |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3993 else |
1655 | 3994 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
|
3995 if (mx >= 0xffff) |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3996 return -1; |
2967 | 3997 |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3998 if (s->umvplus) |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
3999 my = h263p_decode_umotion(s, pred_y); |
2967 | 4000 else |
1655 | 4001 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
|
4002 if (my >= 0xffff) |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4003 return -1; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4004 s->mv[0][i][0] = mx; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4005 s->mv[0][i][1] = my; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4006 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
|
4007 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
|
4008 mot_val[0] = mx; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4009 mot_val[1] = my; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4010 } |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4011 } |
6481 | 4012 } else if(s->pict_type==FF_B_TYPE) { |
1655 | 4013 int mb_type; |
4014 const int stride= s->b8_stride; | |
1701 | 4015 int16_t *mot_val0 = s->current_picture.motion_val[0][ 2*(s->mb_x + s->mb_y*stride) ]; |
4016 int16_t *mot_val1 = s->current_picture.motion_val[1][ 2*(s->mb_x + s->mb_y*stride) ]; | |
1655 | 4017 // const int mv_xy= s->mb_x + 1 + s->mb_y * s->mb_stride; |
4018 | |
2967 | 4019 //FIXME ugly |
4020 mot_val0[0 ]= mot_val0[2 ]= mot_val0[0+2*stride]= mot_val0[2+2*stride]= | |
4021 mot_val0[1 ]= mot_val0[3 ]= mot_val0[1+2*stride]= mot_val0[3+2*stride]= | |
4022 mot_val1[0 ]= mot_val1[2 ]= mot_val1[0+2*stride]= mot_val1[2+2*stride]= | |
1701 | 4023 mot_val1[1 ]= mot_val1[3 ]= mot_val1[1+2*stride]= mot_val1[3+2*stride]= 0; |
1655 | 4024 |
4025 do{ | |
4026 mb_type= get_vlc2(&s->gb, h263_mbtype_b_vlc.table, H263_MBTYPE_B_VLC_BITS, 2); | |
4027 if (mb_type < 0){ | |
4028 av_log(s->avctx, AV_LOG_ERROR, "b mb_type damaged at %d %d\n", s->mb_x, s->mb_y); | |
4029 return -1; | |
4030 } | |
4031 | |
4032 mb_type= h263_mb_type_b_map[ mb_type ]; | |
4033 }while(!mb_type); | |
4034 | |
4035 s->mb_intra = IS_INTRA(mb_type); | |
4036 if(HAS_CBP(mb_type)){ | |
2632 | 4037 s->dsp.clear_blocks(s->block[0]); |
1655 | 4038 cbpc = get_vlc2(&s->gb, cbpc_b_vlc.table, CBPC_B_VLC_BITS, 1); |
4039 if(s->mb_intra){ | |
4040 dquant = IS_QUANT(mb_type); | |
4041 goto intra; | |
4042 } | |
4043 | |
4044 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1); | |
4045 | |
4046 if (cbpy < 0){ | |
4047 av_log(s->avctx, AV_LOG_ERROR, "b cbpy damaged at %d %d\n", s->mb_x, s->mb_y); | |
4048 return -1; | |
4049 } | |
2967 | 4050 |
1655 | 4051 if(s->alt_inter_vlc==0 || (cbpc & 3)!=3) |
4052 cbpy ^= 0xF; | |
2967 | 4053 |
1655 | 4054 cbp = (cbpc & 3) | (cbpy << 2); |
4055 }else | |
4056 cbp=0; | |
2967 | 4057 |
1655 | 4058 assert(!s->mb_intra); |
4059 | |
4060 if(IS_QUANT(mb_type)){ | |
1656 | 4061 h263_decode_dquant(s); |
1655 | 4062 } |
4063 | |
4064 if(IS_DIRECT(mb_type)){ | |
4065 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT; | |
4066 mb_type |= ff_mpeg4_set_direct_mv(s, 0, 0); | |
4067 }else{ | |
4068 s->mv_dir = 0; | |
4069 s->mv_type= MV_TYPE_16X16; | |
4070 //FIXME UMV | |
4071 | |
4072 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
|
4073 int16_t *mot_val= h263_pred_motion(s, 0, 0, &mx, &my); |
1655 | 4074 s->mv_dir = MV_DIR_FORWARD; |
4075 | |
4076 mx = h263_decode_motion(s, mx, 1); | |
4077 my = h263_decode_motion(s, my, 1); | |
2967 | 4078 |
1655 | 4079 s->mv[0][0][0] = mx; |
4080 s->mv[0][0][1] = my; | |
1701 | 4081 mot_val[0 ]= mot_val[2 ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx; |
4082 mot_val[1 ]= mot_val[3 ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my; | |
1655 | 4083 } |
2967 | 4084 |
1655 | 4085 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
|
4086 int16_t *mot_val= h263_pred_motion(s, 0, 1, &mx, &my); |
1655 | 4087 s->mv_dir |= MV_DIR_BACKWARD; |
2967 | 4088 |
1655 | 4089 mx = h263_decode_motion(s, mx, 1); |
4090 my = h263_decode_motion(s, my, 1); | |
1701 | 4091 |
1655 | 4092 s->mv[1][0][0] = mx; |
4093 s->mv[1][0][1] = my; | |
1701 | 4094 mot_val[0 ]= mot_val[2 ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx; |
4095 mot_val[1 ]= mot_val[3 ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my; | |
1655 | 4096 } |
4097 } | |
2967 | 4098 |
1655 | 4099 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
|
4100 } else { /* I-Frame */ |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4101 do{ |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4102 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
|
4103 if (cbpc < 0){ |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4104 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
|
4105 return -1; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4106 } |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4107 }while(cbpc == 8); |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4108 |
2632 | 4109 s->dsp.clear_blocks(s->block[0]); |
4110 | |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4111 dquant = cbpc & 4; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4112 s->mb_intra = 1; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4113 intra: |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4114 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
|
4115 if (s->h263_aic) { |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4116 s->ac_pred = get_bits1(&s->gb); |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4117 if(s->ac_pred){ |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4118 s->current_picture.mb_type[xy]= MB_TYPE_INTRA | MB_TYPE_ACPRED; |
2967 | 4119 |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4120 s->h263_aic_dir = get_bits1(&s->gb); |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4121 } |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4122 }else |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4123 s->ac_pred = 0; |
2967 | 4124 |
9103
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
4125 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
|
4126 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
|
4127 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
|
4128 if(cbpy<0){ |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4129 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
|
4130 return -1; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4131 } |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4132 cbp = (cbpc & 3) | (cbpy << 2); |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4133 if (dquant) { |
1656 | 4134 h263_decode_dquant(s); |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4135 } |
9103
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
4136 |
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
4137 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
|
4138 } |
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
4139 |
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
4140 while(pb_mv_count--){ |
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
4141 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
|
4142 h263_decode_motion(s, 0, 1); |
9093 | 4143 } |
4144 | |
4145 /* decode each block */ | |
4146 for (i = 0; i < 6; i++) { | |
4147 if (h263_decode_block(s, block[i], i, cbp&32) < 0) | |
4148 return -1; | |
4149 cbp+=cbp; | |
4150 } | |
4151 | |
9103
b626fed816d7
Add PB-frame decoding support for H.263/i263 (and enable it for i263)
kostya
parents:
9093
diff
changeset
|
4152 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
|
4153 return -1; |
9093 | 4154 if(s->obmc && !s->mb_intra){ |
4155 if(s->pict_type == FF_P_TYPE && s->mb_x+1<s->mb_width && s->mb_num_left != 1) | |
4156 preview_obmc(s); | |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4157 } |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4158 end: |
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 /* per-MB end of slice check */ |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4161 { |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4162 int v= show_bits(&s->gb, 16); |
2967 | 4163 |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4164 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
|
4165 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
|
4166 } |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4167 |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4168 if(v==0) |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4169 return SLICE_END; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4170 } |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4171 |
2967 | 4172 return SLICE_OK; |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4173 } |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4174 |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4175 int ff_mpeg4_decode_mb(MpegEncContext *s, |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4176 DCTELEM block[6][64]) |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4177 { |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4178 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
|
4179 int16_t *mot_val; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4180 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
|
4181 const int xy= s->mb_x + s->mb_y * s->mb_stride; |
2967 | 4182 |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4183 assert(s->h263_pred); |
2967 | 4184 |
6481 | 4185 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
|
4186 do{ |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4187 if (get_bits1(&s->gb)) { |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4188 /* skip mb */ |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4189 s->mb_intra = 0; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4190 for(i=0;i<6;i++) |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4191 s->block_last_index[i] = -1; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4192 s->mv_dir = MV_DIR_FORWARD; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4193 s->mv_type = MV_TYPE_16X16; |
6481 | 4194 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
|
4195 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
|
4196 s->mcsel=1; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4197 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
|
4198 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
|
4199 |
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
|
4200 s->mb_skipped = 0; |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4201 }else{ |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4202 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
|
4203 s->mcsel=0; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4204 s->mv[0][0][0] = 0; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4205 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
|
4206 s->mb_skipped = 1; |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4207 } |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4208 goto end; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4209 } |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4210 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
|
4211 if (cbpc < 0){ |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4212 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
|
4213 return -1; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4214 } |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4215 }while(cbpc == 20); |
2967 | 4216 |
2632 | 4217 s->dsp.clear_blocks(s->block[0]); |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4218 dquant = cbpc & 8; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4219 s->mb_intra = ((cbpc & 4) != 0); |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4220 if (s->mb_intra) goto intra; |
2967 | 4221 |
6481 | 4222 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
|
4223 s->mcsel= get_bits1(&s->gb); |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4224 else s->mcsel= 0; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4225 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1) ^ 0x0F; |
2967 | 4226 |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4227 cbp = (cbpc & 3) | (cbpy << 2); |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4228 if (dquant) { |
1652 | 4229 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
|
4230 } |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4231 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
|
4232 s->interlaced_dct= get_bits1(&s->gb); |
2967 | 4233 |
0 | 4234 s->mv_dir = MV_DIR_FORWARD; |
4235 if ((cbpc & 16) == 0) { | |
619
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4236 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
|
4237 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
|
4238 /* 16x16 global motion prediction */ |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4239 s->mv_type = MV_TYPE_16X16; |
753 | 4240 mx= get_amv(s, 0); |
4241 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
|
4242 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
|
4243 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
|
4244 }else if((!s->progressive_sequence) && get_bits1(&s->gb)){ |
2967 | 4245 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
|
4246 /* 16x8 field motion prediction */ |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4247 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
|
4248 |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4249 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
|
4250 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
|
4251 |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1936
diff
changeset
|
4252 h263_pred_motion(s, 0, 0, &pred_x, &pred_y); |
2967 | 4253 |
619
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4254 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
|
4255 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
|
4256 if (mx >= 0xffff) |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4257 return -1; |
2967 | 4258 |
619
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4259 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
|
4260 if (my >= 0xffff) |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4261 return -1; |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4262 |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4263 s->mv[0][i][0] = mx; |
661 | 4264 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
|
4265 } |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4266 }else{ |
2967 | 4267 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
|
4268 /* 16x16 motion prediction */ |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4269 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
|
4270 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
|
4271 mx = h263_decode_motion(s, pred_x, s->f_code); |
2967 | 4272 |
619
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4273 if (mx >= 0xffff) |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4274 return -1; |
2967 | 4275 |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4276 my = h263_decode_motion(s, pred_y, s->f_code); |
2967 | 4277 |
619
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4278 if (my >= 0xffff) |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4279 return -1; |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4280 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
|
4281 s->mv[0][0][1] = my; |
255 | 4282 } |
0 | 4283 } else { |
2967 | 4284 s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0; |
0 | 4285 s->mv_type = MV_TYPE_8X8; |
4286 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
|
4287 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
|
4288 mx = h263_decode_motion(s, pred_x, s->f_code); |
0 | 4289 if (mx >= 0xffff) |
4290 return -1; | |
2967 | 4291 |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4292 my = h263_decode_motion(s, pred_y, s->f_code); |
0 | 4293 if (my >= 0xffff) |
4294 return -1; | |
4295 s->mv[0][i][0] = mx; | |
4296 s->mv[0][i][1] = my; | |
4297 mot_val[0] = mx; | |
4298 mot_val[1] = my; | |
4299 } | |
4300 } | |
6481 | 4301 } else if(s->pict_type==FF_B_TYPE) { |
262 | 4302 int modb1; // first bit of modb |
4303 int modb2; // second bit of modb | |
4304 int mb_type; | |
4305 | |
4306 s->mb_intra = 0; //B-frames never contain intra blocks | |
4307 s->mcsel=0; // ... true gmc blocks | |
4308 | |
4309 if(s->mb_x==0){ | |
674 | 4310 for(i=0; i<2; i++){ |
2967 | 4311 s->last_mv[i][0][0]= |
4312 s->last_mv[i][0][1]= | |
4313 s->last_mv[i][1][0]= | |
674 | 4314 s->last_mv[i][1][1]= 0; |
4315 } | |
262 | 4316 } |
4317 | |
4318 /* 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
|
4319 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
|
4320 |
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
|
4321 if(s->mb_skipped){ |
262 | 4322 /* skip mb */ |
4323 for(i=0;i<6;i++) | |
4324 s->block_last_index[i] = -1; | |
4325 | |
4326 s->mv_dir = MV_DIR_FORWARD; | |
4327 s->mv_type = MV_TYPE_16X16; | |
4328 s->mv[0][0][0] = 0; | |
4329 s->mv[0][0][1] = 0; | |
4330 s->mv[1][0][0] = 0; | |
4331 s->mv[1][0][1] = 0; | |
2967 | 4332 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
|
4333 goto end; |
262 | 4334 } |
4335 | |
2967 | 4336 modb1= get_bits1(&s->gb); |
666 | 4337 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
|
4338 mb_type= MB_TYPE_DIRECT2 | MB_TYPE_SKIP | MB_TYPE_L0L1; //like MB_TYPE_B_DIRECT but no vectors coded |
666 | 4339 cbp=0; |
4340 }else{ | |
262 | 4341 modb2= get_bits1(&s->gb); |
544 | 4342 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
|
4343 if(mb_type<0){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
4344 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
|
4345 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
|
4346 } |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
4347 mb_type= mb_type_b_map[ mb_type ]; |
666 | 4348 if(modb2) cbp= 0; |
2632 | 4349 else{ |
4350 s->dsp.clear_blocks(s->block[0]); | |
4351 cbp= get_bits(&s->gb, 6); | |
4352 } | |
666 | 4353 |
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
|
4354 if ((!IS_DIRECT(mb_type)) && cbp) { |
262 | 4355 if(get_bits1(&s->gb)){ |
1652 | 4356 ff_set_qscale(s, s->qscale + get_bits1(&s->gb)*4 - 2); |
262 | 4357 } |
4358 } | |
664 | 4359 |
4360 if(!s->progressive_sequence){ | |
4361 if(cbp) | |
4362 s->interlaced_dct= get_bits1(&s->gb); | |
4363 | |
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
|
4364 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
|
4365 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
|
4366 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
|
4367 |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1176
diff
changeset
|
4368 if(USES_LIST(mb_type, 0)){ |
667 | 4369 s->field_select[0][0]= get_bits1(&s->gb); |
4370 s->field_select[0][1]= get_bits1(&s->gb); | |
4371 } | |
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(USES_LIST(mb_type, 1)){ |
667 | 4373 s->field_select[1][0]= get_bits1(&s->gb); |
4374 s->field_select[1][1]= get_bits1(&s->gb); | |
4375 } | |
4376 } | |
666 | 4377 } |
4378 | |
667 | 4379 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
|
4380 if((mb_type & (MB_TYPE_DIRECT2|MB_TYPE_INTERLACED)) == 0){ |
666 | 4381 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
|
4382 |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead 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(USES_LIST(mb_type, 0)){ |
666 | 4384 s->mv_dir = MV_DIR_FORWARD; |
4385 | |
4386 mx = h263_decode_motion(s, s->last_mv[0][0][0], s->f_code); | |
4387 my = h263_decode_motion(s, s->last_mv[0][0][1], s->f_code); | |
4388 s->last_mv[0][1][0]= s->last_mv[0][0][0]= s->mv[0][0][0] = mx; | |
4389 s->last_mv[0][1][1]= s->last_mv[0][0][1]= s->mv[0][0][1] = my; | |
667 | 4390 } |
2967 | 4391 |
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
|
4392 if(USES_LIST(mb_type, 1)){ |
666 | 4393 s->mv_dir |= MV_DIR_BACKWARD; |
4394 | |
4395 mx = h263_decode_motion(s, s->last_mv[1][0][0], s->b_code); | |
4396 my = h263_decode_motion(s, s->last_mv[1][0][1], s->b_code); | |
4397 s->last_mv[1][1][0]= s->last_mv[1][0][0]= s->mv[1][0][0] = mx; | |
4398 s->last_mv[1][1][1]= s->last_mv[1][0][1]= s->mv[1][0][1] = my; | |
4399 } | |
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
|
4400 }else if(!IS_DIRECT(mb_type)){ |
666 | 4401 s->mv_type= MV_TYPE_FIELD; |
667 | 4402 |
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
|
4403 if(USES_LIST(mb_type, 0)){ |
666 | 4404 s->mv_dir = MV_DIR_FORWARD; |
2967 | 4405 |
666 | 4406 for(i=0; i<2; i++){ |
4407 mx = h263_decode_motion(s, s->last_mv[0][i][0] , s->f_code); | |
4408 my = h263_decode_motion(s, s->last_mv[0][i][1]/2, s->f_code); | |
4409 s->last_mv[0][i][0]= s->mv[0][i][0] = mx; | |
4410 s->last_mv[0][i][1]= (s->mv[0][i][1] = my)*2; | |
4411 } | |
667 | 4412 } |
2967 | 4413 |
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
|
4414 if(USES_LIST(mb_type, 1)){ |
666 | 4415 s->mv_dir |= MV_DIR_BACKWARD; |
4416 | |
4417 for(i=0; i<2; i++){ | |
4418 mx = h263_decode_motion(s, s->last_mv[1][i][0] , s->b_code); | |
4419 my = h263_decode_motion(s, s->last_mv[1][i][1]/2, s->b_code); | |
4420 s->last_mv[1][i][0]= s->mv[1][i][0] = mx; | |
4421 s->last_mv[1][i][1]= (s->mv[1][i][1] = my)*2; | |
664 | 4422 } |
4423 } | |
4424 } | |
4425 } | |
2967 | 4426 |
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
|
4427 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
|
4428 if(IS_SKIP(mb_type)) |
666 | 4429 mx=my=0; |
4430 else{ | |
4431 mx = h263_decode_motion(s, 0, 1); | |
4432 my = h263_decode_motion(s, 0, 1); | |
4433 } | |
2967 | 4434 |
262 | 4435 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
|
4436 mb_type |= ff_mpeg4_set_direct_mv(s, mx, my); |
664 | 4437 } |
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
|
4438 s->current_picture.mb_type[xy]= mb_type; |
262 | 4439 } else { /* I-Frame */ |
1482 | 4440 do{ |
4441 cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2); | |
4442 if (cbpc < 0){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
4443 av_log(s->avctx, AV_LOG_ERROR, "I cbpc damaged at %d %d\n", s->mb_x, s->mb_y); |
1482 | 4444 return -1; |
4445 } | |
4446 }while(cbpc == 8); | |
4447 | |
262 | 4448 dquant = cbpc & 4; |
4449 s->mb_intra = 1; | |
4450 intra: | |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4451 s->ac_pred = get_bits1(&s->gb); |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4452 if(s->ac_pred) |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4453 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
|
4454 else |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4455 s->current_picture.mb_type[xy]= MB_TYPE_INTRA; |
2967 | 4456 |
544 | 4457 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1); |
1482 | 4458 if(cbpy<0){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
4459 av_log(s->avctx, AV_LOG_ERROR, "I cbpy damaged at %d %d\n", s->mb_x, s->mb_y); |
1482 | 4460 return -1; |
4461 } | |
0 | 4462 cbp = (cbpc & 3) | (cbpy << 2); |
3282 | 4463 |
4464 s->use_intra_dc_vlc= s->qscale < s->intra_dc_threshold; | |
4465 | |
0 | 4466 if (dquant) { |
1652 | 4467 ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]); |
0 | 4468 } |
2967 | 4469 |
619
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4470 if(!s->progressive_sequence) |
2be2cc8fd0a1
mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents:
617
diff
changeset
|
4471 s->interlaced_dct= get_bits1(&s->gb); |
575 | 4472 |
2632 | 4473 s->dsp.clear_blocks(s->block[0]); |
575 | 4474 /* decode each block */ |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4475 for (i = 0; i < 6; i++) { |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4476 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
|
4477 return -1; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4478 cbp+=cbp; |
575 | 4479 } |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4480 goto end; |
0 | 4481 } |
4482 | |
4483 /* decode each block */ | |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4484 for (i = 0; i < 6; i++) { |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4485 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
|
4486 return -1; |
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
4487 cbp+=cbp; |
0 | 4488 } |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4489 end: |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4490 |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4491 /* per-MB end of slice check */ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4492 if(s->codec_id==CODEC_ID_MPEG4){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4493 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
|
4494 const int delta= s->mb_x + 1 == s->mb_width ? 2 : 1; |
6481 | 4495 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
|
4496 return SLICE_OK; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4497 return SLICE_END; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4498 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4499 } |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4500 |
2967 | 4501 return SLICE_OK; |
0 | 4502 } |
4503 | |
262 | 4504 static int h263_decode_motion(MpegEncContext * s, int pred, int f_code) |
0 | 4505 { |
656
e47fa3e3f2d5
statistics for forw & back p-MBs instead of just one counter for both
michaelni
parents:
654
diff
changeset
|
4506 int code, val, sign, shift, l; |
544 | 4507 code = get_vlc2(&s->gb, mv_vlc.table, MV_VLC_BITS, 2); |
0 | 4508 |
4509 if (code == 0) | |
4510 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
|
4511 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
|
4512 return 0xffff; |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
702
diff
changeset
|
4513 |
21 | 4514 sign = get_bits1(&s->gb); |
262 | 4515 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
|
4516 val = code; |
625ccacd1113
decode motion & modulo optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1254
diff
changeset
|
4517 if (shift) { |
625ccacd1113
decode motion & modulo optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1254
diff
changeset
|
4518 val = (val - 1) << shift; |
0 | 4519 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
|
4520 val++; |
625ccacd1113
decode motion & modulo optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents:
1254
diff
changeset
|
4521 } |
0 | 4522 if (sign) |
4523 val = -val; | |
4524 val += pred; | |
475 | 4525 |
0 | 4526 /* modulo decoding */ |
4527 if (!s->h263_long_vectors) { | |
2093 | 4528 l = INT_BIT - 5 - f_code; |
4529 val = (val<<l)>>l; | |
0 | 4530 } else { |
4531 /* horrible h263 long vector mode */ | |
4532 if (pred < -31 && val < -63) | |
4533 val += 64; | |
4534 if (pred > 32 && val > 63) | |
4535 val -= 64; | |
2967 | 4536 |
0 | 4537 } |
4538 return val; | |
4539 } | |
4540 | |
78 | 4541 /* Decodes RVLC of H.263+ UMV */ |
4542 static int h263p_decode_umotion(MpegEncContext * s, int pred) | |
4543 { | |
4544 int code = 0, sign; | |
2967 | 4545 |
78 | 4546 if (get_bits1(&s->gb)) /* Motion difference = 0 */ |
4547 return pred; | |
2967 | 4548 |
78 | 4549 code = 2 + get_bits1(&s->gb); |
2967 | 4550 |
78 | 4551 while (get_bits1(&s->gb)) |
4552 { | |
4553 code <<= 1; | |
4554 code += get_bits1(&s->gb); | |
4555 } | |
4556 sign = code & 1; | |
4557 code >>= 1; | |
2967 | 4558 |
78 | 4559 code = (sign) ? (pred - code) : (pred + code); |
9999
c78fd9154378
Change av_log() calls surrounded by '#ifdef DEBUG' into dprintf macros.
diego
parents:
9591
diff
changeset
|
4560 dprintf(s->avctx,"H.263+ UMV Motion = %d\n", code); |
2967 | 4561 return code; |
78 | 4562 |
4563 } | |
4564 | |
0 | 4565 static int h263_decode_block(MpegEncContext * s, DCTELEM * block, |
4566 int n, int coded) | |
4567 { | |
4568 int code, level, i, j, last, run; | |
4569 RLTable *rl = &rl_inter; | |
1064 | 4570 const uint8_t *scan_table; |
1637 | 4571 GetBitContext gb= s->gb; |
0 | 4572 |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
702
diff
changeset
|
4573 scan_table = s->intra_scantable.permutated; |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
4574 if (s->h263_aic && s->mb_intra) { |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
4575 rl = &rl_intra_aic; |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
4576 i = 0; |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
4577 if (s->ac_pred) { |
2967 | 4578 if (s->h263_aic_dir) |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
702
diff
changeset
|
4579 scan_table = s->intra_v_scantable.permutated; /* left */ |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
4580 else |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
702
diff
changeset
|
4581 scan_table = s->intra_h_scantable.permutated; /* top */ |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
4582 } |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
4583 } else if (s->mb_intra) { |
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
4584 /* DC coef */ |
1641 | 4585 if(s->codec_id == CODEC_ID_RV10){ |
8590 | 4586 #if CONFIG_RV10_DECODER |
6481 | 4587 if (s->rv10_version == 3 && s->pict_type == FF_I_TYPE) { |
0 | 4588 int component, diff; |
4589 component = (n <= 3 ? 0 : n - 4 + 1); | |
4590 level = s->last_dc[component]; | |
4591 if (s->rv10_first_dc_coded[component]) { | |
4592 diff = rv_decode_dc(s, n); | |
4593 if (diff == 0xffff) | |
4594 return -1; | |
4595 level += diff; | |
4596 level = level & 0xff; /* handle wrap round */ | |
4597 s->last_dc[component] = level; | |
4598 } else { | |
4599 s->rv10_first_dc_coded[component] = 1; | |
4600 } | |
1090 | 4601 } else { |
4602 level = get_bits(&s->gb, 8); | |
1975 | 4603 if (level == 255) |
4604 level = 128; | |
1090 | 4605 } |
2639 | 4606 #endif |
1090 | 4607 }else{ |
0 | 4608 level = get_bits(&s->gb, 8); |
1089 | 4609 if((level&0x7F) == 0){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
4610 av_log(s->avctx, AV_LOG_ERROR, "illegal dc %d at %d %d\n", level, s->mb_x, s->mb_y); |
7831 | 4611 if(s->error_recognition >= FF_ER_COMPLIANT) |
1752 | 4612 return -1; |
1089 | 4613 } |
0 | 4614 if (level == 255) |
4615 level = 128; | |
4616 } | |
4617 block[0] = level; | |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
4618 i = 1; |
0 | 4619 } else { |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
4620 i = 0; |
0 | 4621 } |
4622 if (!coded) { | |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
4623 if (s->mb_intra && s->h263_aic) |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
4624 goto not_coded; |
0 | 4625 s->block_last_index[n] = i - 1; |
4626 return 0; | |
4627 } | |
1637 | 4628 retry: |
0 | 4629 for(;;) { |
544 | 4630 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
|
4631 if (code < 0){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
4632 av_log(s->avctx, AV_LOG_ERROR, "illegal ac vlc code at %dx%d\n", s->mb_x, s->mb_y); |
0 | 4633 return -1; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4634 } |
0 | 4635 if (code == rl->n) { |
4636 /* escape */ | |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
4637 if (s->h263_flv > 1) { |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
4638 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
|
4639 last = get_bits1(&s->gb); |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
4640 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
|
4641 if(is11){ |
1356 | 4642 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
|
4643 } else { |
1356 | 4644 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
|
4645 } |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
4646 } else { |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
4647 last = get_bits1(&s->gb); |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
4648 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
|
4649 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
|
4650 if(level == -128){ |
1641 | 4651 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
|
4652 /* XXX: should patch encoder too */ |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
4653 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
|
4654 }else{ |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
4655 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
|
4656 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
|
4657 } |
1089 | 4658 } |
0 | 4659 } |
4660 } else { | |
4661 run = rl->table_run[code]; | |
4662 level = rl->table_level[code]; | |
4663 last = code >= rl->last; | |
21 | 4664 if (get_bits1(&s->gb)) |
0 | 4665 level = -level; |
4666 } | |
4667 i += run; | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4668 if (i >= 64){ |
1637 | 4669 if(s->alt_inter_vlc && rl == &rl_inter && !s->mb_intra){ |
5129 | 4670 //Looks like a hack but no, it's the way it is supposed to work ... |
1637 | 4671 rl = &rl_intra_aic; |
4672 i = 0; | |
4673 s->gb= gb; | |
8288 | 4674 s->dsp.clear_block(block); |
1637 | 4675 goto retry; |
4676 } | |
2406 | 4677 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 | 4678 return -1; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4679 } |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
4680 j = scan_table[i]; |
0 | 4681 block[j] = level; |
4682 if (last) | |
4683 break; | |
4684 i++; | |
4685 } | |
2967 | 4686 not_coded: |
249
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
4687 if (s->mb_intra && s->h263_aic) { |
42a0b7b16738
- Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents:
248
diff
changeset
|
4688 h263_pred_acdc(s, block, n); |
265
4e9e728021d8
use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents:
264
diff
changeset
|
4689 i = 63; |
248
56ee684c48bb
- H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents:
245
diff
changeset
|
4690 } |
0 | 4691 s->block_last_index[n] = i; |
4692 return 0; | |
4693 } | |
4694 | |
1034 | 4695 /** |
4696 * decodes the dc value. | |
4697 * @param n block index (0-3 are luma, 4-5 are chroma) | |
4698 * @param dir_ptr the prediction direction will be stored here | |
4699 * @return the quantized dc | |
4700 */ | |
453 | 4701 static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr) |
0 | 4702 { |
2003 | 4703 int level, code; |
0 | 4704 |
2967 | 4705 if (n < 4) |
544 | 4706 code = get_vlc2(&s->gb, dc_lum.table, DC_VLC_BITS, 1); |
2967 | 4707 else |
544 | 4708 code = get_vlc2(&s->gb, dc_chrom.table, DC_VLC_BITS, 1); |
453 | 4709 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
|
4710 av_log(s->avctx, AV_LOG_ERROR, "illegal dc vlc\n"); |
0 | 4711 return -1; |
453 | 4712 } |
0 | 4713 if (code == 0) { |
4714 level = 0; | |
4715 } 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
|
4716 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
|
4717 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
|
4718 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
|
4719 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
|
4720 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
|
4721 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
|
4722 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
|
4723 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
|
4724 } |
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
|
4725 }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
|
4726 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
|
4727 } |
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
|
4728 |
453 | 4729 if (code > 8){ |
4730 if(get_bits1(&s->gb)==0){ /* marker */ | |
7831 | 4731 if(s->error_recognition>=2){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
4732 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
|
4733 return -1; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4734 } |
453 | 4735 } |
4736 } | |
0 | 4737 } |
2003 | 4738 |
4739 return ff_mpeg4_pred_dc(s, n, level, dir_ptr, 0); | |
0 | 4740 } |
4741 | |
453 | 4742 /** |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4743 * decodes a block. |
6524 | 4744 * @return <0 if an error occurred |
453 | 4745 */ |
4746 static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block, | |
1132 | 4747 int n, int coded, int intra, int rvlc) |
0 | 4748 { |
549 | 4749 int level, i, last, run; |
6211
ed359f380aa7
Revert r11689 and r11690 (uninitalized warning fix) as its theoretically
michael
parents:
6209
diff
changeset
|
4750 int dc_pred_dir; |
575 | 4751 RLTable * rl; |
4752 RL_VLC_ELEM * rl_vlc; | |
1064 | 4753 const uint8_t * scan_table; |
549 | 4754 int qmul, qadd; |
0 | 4755 |
1132 | 4756 //Note intra & rvlc should be optimized away if this is inlined |
2967 | 4757 |
575 | 4758 if(intra) { |
3282 | 4759 if(s->use_intra_dc_vlc){ |
2979 | 4760 /* DC coef */ |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4761 if(s->partitioned_frame){ |
453 | 4762 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
|
4763 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
|
4764 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
|
4765 dc_pred_dir= (s->pred_dir_table[s->mb_x + s->mb_y*s->mb_stride]<<n)&32; |
453 | 4766 }else{ |
4767 level = mpeg4_decode_dc(s, n, &dc_pred_dir); | |
4768 if (level < 0) | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
4769 return -1; |
453 | 4770 } |
0 | 4771 block[0] = level; |
549 | 4772 i = 0; |
1520 | 4773 }else{ |
4774 i = -1; | |
3182 | 4775 ff_mpeg4_pred_dc(s, n, 0, &dc_pred_dir, 0); |
2967 | 4776 } |
6201 | 4777 if (!coded) |
4778 goto not_coded; | |
4779 | |
4780 if(rvlc){ | |
4781 rl = &rvlc_rl_intra; | |
4782 rl_vlc = rvlc_rl_intra.rl_vlc[0]; | |
4783 }else{ | |
4784 rl = &rl_intra; | |
4785 rl_vlc = rl_intra.rl_vlc[0]; | |
4786 } | |
4787 if (s->ac_pred) { | |
4788 if (dc_pred_dir == 0) | |
4789 scan_table = s->intra_v_scantable.permutated; /* left */ | |
4790 else | |
4791 scan_table = s->intra_h_scantable.permutated; /* top */ | |
4792 } else { | |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
702
diff
changeset
|
4793 scan_table = s->intra_scantable.permutated; |
6201 | 4794 } |
4795 qmul=1; | |
4796 qadd=0; | |
0 | 4797 } else { |
549 | 4798 i = -1; |
0 | 4799 if (!coded) { |
549 | 4800 s->block_last_index[n] = i; |
0 | 4801 return 0; |
4802 } | |
1132 | 4803 if(rvlc) rl = &rvlc_rl_inter; |
4804 else rl = &rl_inter; | |
2967 | 4805 |
718 | 4806 scan_table = s->intra_scantable.permutated; |
661 | 4807 |
591 | 4808 if(s->mpeg_quant){ |
4809 qmul=1; | |
4810 qadd=0; | |
2967 | 4811 if(rvlc){ |
4812 rl_vlc = rvlc_rl_inter.rl_vlc[0]; | |
1132 | 4813 }else{ |
2967 | 4814 rl_vlc = rl_inter.rl_vlc[0]; |
1132 | 4815 } |
591 | 4816 }else{ |
4817 qmul = s->qscale << 1; | |
4818 qadd = (s->qscale - 1) | 1; | |
2967 | 4819 if(rvlc){ |
4820 rl_vlc = rvlc_rl_inter.rl_vlc[s->qscale]; | |
1132 | 4821 }else{ |
2967 | 4822 rl_vlc = rl_inter.rl_vlc[s->qscale]; |
1132 | 4823 } |
591 | 4824 } |
0 | 4825 } |
549 | 4826 { |
4827 OPEN_READER(re, &s->gb); | |
0 | 4828 for(;;) { |
549 | 4829 UPDATE_CACHE(re, &s->gb); |
2615
0d88e3f89379
avoid UPDATE_CACHE() in GET_RL_VLC() if not needed
michael
parents:
2572
diff
changeset
|
4830 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 0); |
549 | 4831 if (level==0) { |
2967 | 4832 /* escape */ |
1132 | 4833 if(rvlc){ |
4834 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
|
4835 av_log(s->avctx, AV_LOG_ERROR, "1. marker bit missing in rvlc esc\n"); |
1132 | 4836 return -1; |
4837 }; SKIP_CACHE(re, &s->gb, 1); | |
2967 | 4838 |
1132 | 4839 last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1); |
4840 run= SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6); | |
4841 SKIP_COUNTER(re, &s->gb, 1+1+6); | |
4842 UPDATE_CACHE(re, &s->gb); | |
2967 | 4843 |
1132 | 4844 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
|
4845 av_log(s->avctx, AV_LOG_ERROR, "2. marker bit missing in rvlc esc\n"); |
1132 | 4846 return -1; |
4847 }; SKIP_CACHE(re, &s->gb, 1); | |
2967 | 4848 |
1132 | 4849 level= SHOW_UBITS(re, &s->gb, 11); SKIP_CACHE(re, &s->gb, 11); |
2967 | 4850 |
1132 | 4851 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
|
4852 av_log(s->avctx, AV_LOG_ERROR, "reverse esc missing\n"); |
1132 | 4853 return -1; |
4854 }; SKIP_CACHE(re, &s->gb, 5); | |
4855 | |
4856 level= level * qmul + qadd; | |
4857 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); LAST_SKIP_CACHE(re, &s->gb, 1); | |
4858 SKIP_COUNTER(re, &s->gb, 1+11+5+1); | |
4859 | |
4860 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
|
4861 if(last) i+=192; |
1132 | 4862 }else{ |
549 | 4863 int cache; |
4864 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
|
4865 |
2967 | 4866 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
|
4867 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
|
4868 |
549 | 4869 if (cache&0x80000000) { |
4870 if (cache&0x40000000) { | |
0 | 4871 /* third escape */ |
549 | 4872 SKIP_CACHE(re, &s->gb, 2); |
4873 last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1); | |
4874 run= SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6); | |
4875 SKIP_COUNTER(re, &s->gb, 2+1+6); | |
4876 UPDATE_CACHE(re, &s->gb); | |
4877 | |
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
|
4878 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
|
4879 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
|
4880 }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
|
4881 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
|
4882 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
|
4883 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
|
4884 }; 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
|
4885 |
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
|
4886 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
|
4887 |
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
|
4888 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
|
4889 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
|
4890 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
|
4891 }; 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
|
4892 |
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
|
4893 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
|
4894 } |
2967 | 4895 |
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
|
4896 #if 0 |
7831 | 4897 if(s->error_recognition >= FF_ER_COMPLIANT){ |
4001 | 4898 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
|
4899 if(abs_level<=MAX_LEVEL && run<=MAX_RUN){ |
498 | 4900 const int run1= run - rl->max_run[last][abs_level] - 1; |
453 | 4901 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
|
4902 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
|
4903 return -1; |
453 | 4904 } |
7831 | 4905 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
|
4906 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
|
4907 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
|
4908 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
|
4909 } |
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
|
4910 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
|
4911 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
|
4912 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
|
4913 } |
453 | 4914 } |
4915 } | |
4916 } | |
4917 #endif | |
2979 | 4918 if (level>0) level= level * qmul + qadd; |
549 | 4919 else level= level * qmul - qadd; |
4920 | |
2080 | 4921 if((unsigned)(level + 2048) > 4095){ |
7831 | 4922 if(s->error_recognition > FF_ER_COMPLIANT){ |
2080 | 4923 if(level > 2560 || level<-2560){ |
4924 av_log(s->avctx, AV_LOG_ERROR, "|level| overflow in 3. esc, qp=%d\n", s->qscale); | |
4925 return -1; | |
4926 } | |
4927 } | |
4928 level= level<0 ? -2048 : 2047; | |
4929 } | |
4930 | |
549 | 4931 i+= run + 1; |
4932 if(last) i+=192; | |
0 | 4933 } else { |
4934 /* second escape */ | |
549 | 4935 #if MIN_CACHE_BITS < 20 |
4936 LAST_SKIP_BITS(re, &s->gb, 2); | |
4937 UPDATE_CACHE(re, &s->gb); | |
4938 #else | |
4939 SKIP_BITS(re, &s->gb, 2); | |
4940 #endif | |
2615
0d88e3f89379
avoid UPDATE_CACHE() in GET_RL_VLC() if not needed
michael
parents:
2572
diff
changeset
|
4941 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1); |
549 | 4942 i+= run + rl->max_run[run>>7][level/qmul] +1; //FIXME opt indexing |
4943 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); | |
4944 LAST_SKIP_BITS(re, &s->gb, 1); | |
0 | 4945 } |
4946 } else { | |
4947 /* first escape */ | |
549 | 4948 #if MIN_CACHE_BITS < 19 |
4949 LAST_SKIP_BITS(re, &s->gb, 1); | |
4950 UPDATE_CACHE(re, &s->gb); | |
4951 #else | |
4952 SKIP_BITS(re, &s->gb, 1); | |
4953 #endif | |
2615
0d88e3f89379
avoid UPDATE_CACHE() in GET_RL_VLC() if not needed
michael
parents:
2572
diff
changeset
|
4954 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1); |
549 | 4955 i+= run; |
4956 level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//FIXME opt indexing | |
4957 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); | |
4958 LAST_SKIP_BITS(re, &s->gb, 1); | |
0 | 4959 } |
1132 | 4960 } |
0 | 4961 } else { |
549 | 4962 i+= run; |
4963 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); | |
4964 LAST_SKIP_BITS(re, &s->gb, 1); | |
0 | 4965 } |
549 | 4966 if (i > 62){ |
4967 i-= 192; | |
4968 if(i&(~63)){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
4969 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
|
4970 return -1; |
549 | 4971 } |
4972 | |
4973 block[scan_table[i]] = level; | |
0 | 4974 break; |
549 | 4975 } |
4976 | |
4977 block[scan_table[i]] = level; | |
0 | 4978 } |
549 | 4979 CLOSE_READER(re, &s->gb); |
4980 } | |
0 | 4981 not_coded: |
1520 | 4982 if (intra) { |
3282 | 4983 if(!s->use_intra_dc_vlc){ |
2003 | 4984 block[0] = ff_mpeg4_pred_dc(s, n, block[0], &dc_pred_dir, 0); |
2967 | 4985 |
3181 | 4986 i -= i>>31; //if(i == -1) i=0; |
1520 | 4987 } |
4988 | |
0 | 4989 mpeg4_pred_ac(s, block, n, dc_pred_dir); |
4990 if (s->ac_pred) { | |
549 | 4991 i = 63; /* XXX: not optimal */ |
0 | 4992 } |
4993 } | |
549 | 4994 s->block_last_index[n] = i; |
0 | 4995 return 0; |
4996 } | |
4997 | |
4998 /* most is hardcoded. should extend to handle all h263 streams */ | |
4999 int h263_decode_picture_header(MpegEncContext *s) | |
5000 { | |
1278
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
5001 int format, width, height, i; |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
5002 uint32_t startcode; |
2967 | 5003 |
1278
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
5004 align_get_bits(&s->gb); |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
5005 |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
5006 startcode= get_bits(&s->gb, 22-8); |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
5007 |
10535
95f3daa991a2
Use get_bits_left() instead of size_in_bits - get_bits_count().
rbultje
parents:
9999
diff
changeset
|
5008 for(i= get_bits_left(&s->gb); i>24; i-=8) { |
1278
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
5009 startcode = ((startcode << 8) | get_bits(&s->gb, 8)) & 0x003FFFFF; |
2967 | 5010 |
1278
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
5011 if(startcode == 0x20) |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
5012 break; |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
5013 } |
2967 | 5014 |
1278
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
5015 if (startcode != 0x20) { |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5016 av_log(s->avctx, AV_LOG_ERROR, "Bad picture start code\n"); |
0 | 5017 return -1; |
355 | 5018 } |
5019 /* temporal reference */ | |
1865 | 5020 i = get_bits(&s->gb, 8); /* picture timestamp */ |
5021 if( (s->picture_number&~0xFF)+i < s->picture_number) | |
5022 i+= 256; | |
2886 | 5023 s->current_picture_ptr->pts= |
1865 | 5024 s->picture_number= (s->picture_number&~0xFF) + i; |
355 | 5025 |
2967 | 5026 /* PTYPE starts here */ |
355 | 5027 if (get_bits1(&s->gb) != 1) { |
5028 /* marker */ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5029 av_log(s->avctx, AV_LOG_ERROR, "Bad marker\n"); |
355 | 5030 return -1; |
5031 } | |
5032 if (get_bits1(&s->gb) != 0) { | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5033 av_log(s->avctx, AV_LOG_ERROR, "Bad H263 id\n"); |
2979 | 5034 return -1; /* h263 id */ |
5035 } | |
5036 skip_bits1(&s->gb); /* split screen off */ | |
5037 skip_bits1(&s->gb); /* camera off */ | |
5038 skip_bits1(&s->gb); /* freeze picture release off */ | |
0 | 5039 |
5040 format = get_bits(&s->gb, 3); | |
355 | 5041 /* |
5042 0 forbidden | |
5043 1 sub-QCIF | |
5044 10 QCIF | |
2979 | 5045 7 extended PTYPE (PLUSPTYPE) |
355 | 5046 */ |
0 | 5047 |
161 | 5048 if (format != 7 && format != 6) { |
0 | 5049 s->h263_plus = 0; |
5050 /* H.263v1 */ | |
5051 width = h263_format[format][0]; | |
5052 height = h263_format[format][1]; | |
5053 if (!width) | |
5054 return -1; | |
2967 | 5055 |
6481 | 5056 s->pict_type = FF_I_TYPE + get_bits1(&s->gb); |
0 | 5057 |
2967 | 5058 s->h263_long_vectors = get_bits1(&s->gb); |
0 | 5059 |
355 | 5060 if (get_bits1(&s->gb) != 0) { |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5061 av_log(s->avctx, AV_LOG_ERROR, "H263 SAC not supported\n"); |
2979 | 5062 return -1; /* SAC: off */ |
355 | 5063 } |
1633 | 5064 s->obmc= get_bits1(&s->gb); /* Advanced prediction mode */ |
5065 s->unrestricted_mv = s->h263_long_vectors || s->obmc; | |
2967 | 5066 |
9104 | 5067 s->pb_frame = get_bits1(&s->gb); |
1644 | 5068 s->chroma_qscale= s->qscale = get_bits(&s->gb, 5); |
2979 | 5069 skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */ |
1393 | 5070 |
5071 s->width = width; | |
5072 s->height = height; | |
1865 | 5073 s->avctx->sample_aspect_ratio= (AVRational){12,11}; |
2637 | 5074 s->avctx->time_base= (AVRational){1001, 30000}; |
0 | 5075 } else { |
161 | 5076 int ufep; |
2967 | 5077 |
0 | 5078 /* H.263v2 */ |
161 | 5079 s->h263_plus = 1; |
5080 ufep = get_bits(&s->gb, 3); /* Update Full Extended PTYPE */ | |
355 | 5081 |
2967 | 5082 /* ufep other than 0 and 1 are reserved */ |
161 | 5083 if (ufep == 1) { |
2967 | 5084 /* OPPTYPE */ |
161 | 5085 format = get_bits(&s->gb, 3); |
4652 | 5086 dprintf(s->avctx, "ufep=1, format: %d\n", format); |
1872 | 5087 s->custom_pcf= get_bits1(&s->gb); |
5513 | 5088 s->umvplus = get_bits1(&s->gb); /* Unrestricted Motion Vector */ |
1644 | 5089 if (get_bits1(&s->gb) != 0) { |
5090 av_log(s->avctx, AV_LOG_ERROR, "Syntax-based Arithmetic Coding (SAC) not supported\n"); | |
5091 } | |
1633 | 5092 s->obmc= get_bits1(&s->gb); /* Advanced prediction mode */ |
5093 s->h263_aic = get_bits1(&s->gb); /* Advanced Intra Coding (AIC) */ | |
1644 | 5094 s->loop_filter= get_bits1(&s->gb); |
5095 s->unrestricted_mv = s->umvplus || s->obmc || s->loop_filter; | |
2967 | 5096 |
1661 | 5097 s->h263_slice_structured= get_bits1(&s->gb); |
1278
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
5098 if (get_bits1(&s->gb) != 0) { |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5099 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
|
5100 } |
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
5101 if (get_bits1(&s->gb) != 0) { |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5102 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
|
5103 } |
1637 | 5104 s->alt_inter_vlc= get_bits1(&s->gb); |
1639 | 5105 s->modified_quant= get_bits1(&s->gb); |
1644 | 5106 if(s->modified_quant) |
5107 s->chroma_qscale_table= ff_h263_chroma_qscale_table; | |
2967 | 5108 |
1278
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
5109 skip_bits(&s->gb, 1); /* Prevent start code emulation */ |
355 | 5110 |
161 | 5111 skip_bits(&s->gb, 3); /* Reserved */ |
355 | 5112 } else if (ufep != 0) { |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5113 av_log(s->avctx, AV_LOG_ERROR, "Bad UFEP type (%d)\n", ufep); |
0 | 5114 return -1; |
355 | 5115 } |
2967 | 5116 |
78 | 5117 /* MPPTYPE */ |
1655 | 5118 s->pict_type = get_bits(&s->gb, 3); |
5119 switch(s->pict_type){ | |
6481 | 5120 case 0: s->pict_type= FF_I_TYPE;break; |
5121 case 1: s->pict_type= FF_P_TYPE;break; | |
9104 | 5122 case 2: s->pict_type= FF_P_TYPE;s->pb_frame = 3;break; |
6481 | 5123 case 3: s->pict_type= FF_B_TYPE;break; |
5124 case 7: s->pict_type= FF_I_TYPE;break; //ZYGO | |
1655 | 5125 default: |
0 | 5126 return -1; |
1655 | 5127 } |
250
3449316664b5
- Bug fix on RTYPE (rounding type) not being honoured by H.263+ decoder.
pulento
parents:
249
diff
changeset
|
5128 skip_bits(&s->gb, 2); |
3449316664b5
- Bug fix on RTYPE (rounding type) not being honoured by H.263+ decoder.
pulento
parents:
249
diff
changeset
|
5129 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
|
5130 skip_bits(&s->gb, 4); |
2967 | 5131 |
78 | 5132 /* Get the picture dimensions */ |
161 | 5133 if (ufep) { |
5134 if (format == 6) { | |
5135 /* Custom Picture Format (CPFMT) */ | |
355 | 5136 s->aspect_ratio_info = get_bits(&s->gb, 4); |
4652 | 5137 dprintf(s->avctx, "aspect: %d\n", s->aspect_ratio_info); |
355 | 5138 /* aspect ratios: |
5139 0 - forbidden | |
5140 1 - 1:1 | |
5141 2 - 12:11 (CIF 4:3) | |
5142 3 - 10:11 (525-type 4:3) | |
5143 4 - 16:11 (CIF 16:9) | |
5144 5 - 40:33 (525-type 16:9) | |
5145 6-14 - reserved | |
5146 */ | |
161 | 5147 width = (get_bits(&s->gb, 9) + 1) * 4; |
5148 skip_bits1(&s->gb); | |
5149 height = get_bits(&s->gb, 9) * 4; | |
4652 | 5150 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
|
5151 if (s->aspect_ratio_info == FF_ASPECT_EXTENDED) { |
355 | 5152 /* aspected dimensions */ |
1548 | 5153 s->avctx->sample_aspect_ratio.num= get_bits(&s->gb, 8); |
5154 s->avctx->sample_aspect_ratio.den= get_bits(&s->gb, 8); | |
887 | 5155 }else{ |
1548 | 5156 s->avctx->sample_aspect_ratio= pixel_aspect[s->aspect_ratio_info]; |
355 | 5157 } |
5158 } else { | |
161 | 5159 width = h263_format[format][0]; |
5160 height = h263_format[format][1]; | |
1865 | 5161 s->avctx->sample_aspect_ratio= (AVRational){12,11}; |
161 | 5162 } |
5163 if ((width == 0) || (height == 0)) | |
5164 return -1; | |
5165 s->width = width; | |
5166 s->height = height; | |
1872 | 5167 |
5168 if(s->custom_pcf){ | |
5169 int gcd; | |
2637 | 5170 s->avctx->time_base.den= 1800000; |
5171 s->avctx->time_base.num= 1000 + get_bits1(&s->gb); | |
5172 s->avctx->time_base.num*= get_bits(&s->gb, 7); | |
5173 if(s->avctx->time_base.num == 0){ | |
1872 | 5174 av_log(s, AV_LOG_ERROR, "zero framerate\n"); |
5175 return -1; | |
5176 } | |
8611 | 5177 gcd= av_gcd(s->avctx->time_base.den, s->avctx->time_base.num); |
2637 | 5178 s->avctx->time_base.den /= gcd; |
5179 s->avctx->time_base.num /= gcd; | |
1872 | 5180 }else{ |
2637 | 5181 s->avctx->time_base= (AVRational){1001, 30000}; |
1872 | 5182 } |
5183 } | |
2967 | 5184 |
1872 | 5185 if(s->custom_pcf){ |
5186 skip_bits(&s->gb, 2); //extended Temporal reference | |
5187 } | |
5188 | |
5189 if (ufep) { | |
1089 | 5190 if (s->umvplus) { |
5191 if(get_bits1(&s->gb)==0) /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */ | |
2967 | 5192 skip_bits1(&s->gb); |
161 | 5193 } |
1661 | 5194 if(s->h263_slice_structured){ |
5195 if (get_bits1(&s->gb) != 0) { | |
5196 av_log(s->avctx, AV_LOG_ERROR, "rectangular slices not supported\n"); | |
5197 } | |
5198 if (get_bits1(&s->gb) != 0) { | |
5199 av_log(s->avctx, AV_LOG_ERROR, "unordered slices not supported\n"); | |
5200 } | |
5201 } | |
78 | 5202 } |
2967 | 5203 |
0 | 5204 s->qscale = get_bits(&s->gb, 5); |
5205 } | |
1670 | 5206 |
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
|
5207 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
|
5208 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
|
5209 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
|
5210 |
9104 | 5211 if (s->pb_frame) { |
5212 skip_bits(&s->gb, 3); /* Temporal reference for B-pictures */ | |
5213 if (s->custom_pcf) | |
5214 skip_bits(&s->gb, 2); //extended Temporal reference | |
5215 skip_bits(&s->gb, 2); /* Quantization information for B-pictures */ | |
5216 } | |
5217 | |
0 | 5218 /* PEI */ |
21 | 5219 while (get_bits1(&s->gb) != 0) { |
5220 skip_bits(&s->gb, 8); | |
0 | 5221 } |
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
|
5222 |
1670 | 5223 if(s->h263_slice_structured){ |
5224 if (get_bits1(&s->gb) != 1) { | |
5225 av_log(s->avctx, AV_LOG_ERROR, "SEPB1 marker missing\n"); | |
5226 return -1; | |
5227 } | |
5228 | |
5229 ff_h263_decode_mba(s); | |
5230 | |
5231 if (get_bits1(&s->gb) != 1) { | |
5232 av_log(s->avctx, AV_LOG_ERROR, "SEPB2 marker missing\n"); | |
5233 return -1; | |
5234 } | |
5235 } | |
0 | 5236 s->f_code = 1; |
2967 | 5237 |
498 | 5238 if(s->h263_aic){ |
2967 | 5239 s->y_dc_scale_table= |
1639 | 5240 s->c_dc_scale_table= ff_aic_dc_scale_table; |
498 | 5241 }else{ |
5242 s->y_dc_scale_table= | |
5243 s->c_dc_scale_table= ff_mpeg1_dc_scale_table; | |
5244 } | |
5245 | |
1278
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
5246 if(s->avctx->debug&FF_DEBUG_PICT_INFO){ |
5403 | 5247 show_pict_info(s); |
1278
483db104bb7b
truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents:
1273
diff
changeset
|
5248 } |
8612 | 5249 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
|
5250 int i,j; |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5251 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
|
5252 av_log(s->avctx, AV_LOG_DEBUG, "\n"); |
1584
3615999a7284
dumping funny numbers from first zygo i frame header
michael
parents:
1583
diff
changeset
|
5253 for(i=0; i<13; i++){ |
3615999a7284
dumping funny numbers from first zygo i frame header
michael
parents:
1583
diff
changeset
|
5254 for(j=0; j<3; j++){ |
3615999a7284
dumping funny numbers from first zygo i frame header
michael
parents:
1583
diff
changeset
|
5255 int v= get_bits(&s->gb, 8); |
3615999a7284
dumping funny numbers from first zygo i frame header
michael
parents:
1583
diff
changeset
|
5256 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
|
5257 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
|
5258 } |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5259 av_log(s->avctx, AV_LOG_DEBUG, "\n"); |
1584
3615999a7284
dumping funny numbers from first zygo i frame header
michael
parents:
1583
diff
changeset
|
5260 } |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5261 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
|
5262 } |
3615999a7284
dumping funny numbers from first zygo i frame header
michael
parents:
1583
diff
changeset
|
5263 |
0 | 5264 return 0; |
5265 } | |
5266 | |
1914 | 5267 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
|
5268 { |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5269 int i; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5270 int a= 2<<s->sprite_warping_accuracy; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5271 int rho= 3-s->sprite_warping_accuracy; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5272 int r=16/a; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5273 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
|
5274 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
|
5275 int sprite_ref[4][2]; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5276 int virtual_ref[2][2]; |
753 | 5277 int w2, h2, w3, h3; |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5278 int alpha=0, beta=0; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5279 int w= s->width; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5280 int h= s->height; |
753 | 5281 int min_ab; |
5282 | |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5283 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
|
5284 int length; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5285 int x=0, y=0; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5286 |
3024
67d3bb5a4ce1
get_vlc -> get_vlc2 transition and get_vlc() removed from bitstream.h
banan
parents:
2985
diff
changeset
|
5287 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
|
5288 if(length){ |
1914 | 5289 x= get_xbits(gb, length); |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5290 } |
1914 | 5291 if(!(s->divx_version==500 && s->divx_build==413)) skip_bits1(gb); /* marker bit */ |
2967 | 5292 |
3024
67d3bb5a4ce1
get_vlc -> get_vlc2 transition and get_vlc() removed from bitstream.h
banan
parents:
2985
diff
changeset
|
5293 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
|
5294 if(length){ |
1914 | 5295 y=get_xbits(gb, length); |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5296 } |
1914 | 5297 skip_bits1(gb); /* marker bit */ |
9290
0bd35457454e
Record MPEG-4 sprite trajectory points [up to num_sprite_warping_points][isY].
gb
parents:
9259
diff
changeset
|
5298 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
|
5299 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
|
5300 } |
0bd35457454e
Record MPEG-4 sprite trajectory points [up to num_sprite_warping_points][isY].
gb
parents:
9259
diff
changeset
|
5301 for(; i<4; i++) |
0bd35457454e
Record MPEG-4 sprite trajectory points [up to num_sprite_warping_points][isY].
gb
parents:
9259
diff
changeset
|
5302 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
|
5303 |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5304 while((1<<alpha)<w) alpha++; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5305 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
|
5306 w2= 1<<alpha; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5307 h2= 1<<beta; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5308 |
2646
c735e3e60ca7
Even More spelling errors. patch by (Kevin Baragona <kevinmb500 gawab com)
michael
parents:
2639
diff
changeset
|
5309 // Note, the 4th point isn't used for GMC |
262 | 5310 if(s->divx_version==500 && s->divx_build==413){ |
5311 sprite_ref[0][0]= a*vop_ref[0][0] + d[0][0]; | |
5312 sprite_ref[0][1]= a*vop_ref[0][1] + d[0][1]; | |
5313 sprite_ref[1][0]= a*vop_ref[1][0] + d[0][0] + d[1][0]; | |
5314 sprite_ref[1][1]= a*vop_ref[1][1] + d[0][1] + d[1][1]; | |
5315 sprite_ref[2][0]= a*vop_ref[2][0] + d[0][0] + d[2][0]; | |
5316 sprite_ref[2][1]= a*vop_ref[2][1] + d[0][1] + d[2][1]; | |
5317 } else { | |
5318 sprite_ref[0][0]= (a>>1)*(2*vop_ref[0][0] + d[0][0]); | |
5319 sprite_ref[0][1]= (a>>1)*(2*vop_ref[0][1] + d[0][1]); | |
5320 sprite_ref[1][0]= (a>>1)*(2*vop_ref[1][0] + d[0][0] + d[1][0]); | |
5321 sprite_ref[1][1]= (a>>1)*(2*vop_ref[1][1] + d[0][1] + d[1][1]); | |
5322 sprite_ref[2][0]= (a>>1)*(2*vop_ref[2][0] + d[0][0] + d[2][0]); | |
5323 sprite_ref[2][1]= (a>>1)*(2*vop_ref[2][1] + d[0][1] + d[2][1]); | |
5324 } | |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5325 /* 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
|
5326 sprite_ref[3][1]= (a>>1)*(2*vop_ref[3][1] + d[0][1] + d[1][1] + d[2][1] + d[3][1]); */ |
2967 | 5327 |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5328 // 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
|
5329 // 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
|
5330 // 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
|
5331 // so the distance between points is converted from w&h based to w2&h2 based which are of the 2^x form |
2967 | 5332 virtual_ref[0][0]= 16*(vop_ref[0][0] + w2) |
359 | 5333 + 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 | 5334 virtual_ref[0][1]= 16*vop_ref[0][1] |
359 | 5335 + 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 | 5336 virtual_ref[1][0]= 16*vop_ref[0][0] |
359 | 5337 + 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 | 5338 virtual_ref[1][1]= 16*(vop_ref[0][1] + h2) |
359 | 5339 + 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 | 5340 |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5341 switch(s->num_sprite_warping_points) |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5342 { |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5343 case 0: |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5344 s->sprite_offset[0][0]= 0; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5345 s->sprite_offset[0][1]= 0; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5346 s->sprite_offset[1][0]= 0; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5347 s->sprite_offset[1][1]= 0; |
753 | 5348 s->sprite_delta[0][0]= a; |
5349 s->sprite_delta[0][1]= 0; | |
5350 s->sprite_delta[1][0]= 0; | |
5351 s->sprite_delta[1][1]= a; | |
5352 s->sprite_shift[0]= 0; | |
5353 s->sprite_shift[1]= 0; | |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5354 break; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5355 case 1: //GMC only |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5356 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
|
5357 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
|
5358 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
|
5359 s->sprite_offset[1][1]= ((sprite_ref[0][1]>>1)|(sprite_ref[0][1]&1)) - a*(vop_ref[0][1]/2); |
753 | 5360 s->sprite_delta[0][0]= a; |
5361 s->sprite_delta[0][1]= 0; | |
5362 s->sprite_delta[1][0]= 0; | |
5363 s->sprite_delta[1][1]= a; | |
5364 s->sprite_shift[0]= 0; | |
5365 s->sprite_shift[1]= 0; | |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5366 break; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5367 case 2: |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5368 s->sprite_offset[0][0]= (sprite_ref[0][0]<<(alpha+rho)) |
753 | 5369 + (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][0]) |
5370 + ( r*sprite_ref[0][1] - virtual_ref[0][1])*(-vop_ref[0][1]) | |
5371 + (1<<(alpha+rho-1)); | |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5372 s->sprite_offset[0][1]= (sprite_ref[0][1]<<(alpha+rho)) |
753 | 5373 + (-r*sprite_ref[0][1] + virtual_ref[0][1])*(-vop_ref[0][0]) |
5374 + (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][1]) | |
5375 + (1<<(alpha+rho-1)); | |
5376 s->sprite_offset[1][0]= ( (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][0] + 1) | |
5377 +( r*sprite_ref[0][1] - virtual_ref[0][1])*(-2*vop_ref[0][1] + 1) | |
2967 | 5378 +2*w2*r*sprite_ref[0][0] |
5379 - 16*w2 | |
753 | 5380 + (1<<(alpha+rho+1))); |
2967 | 5381 s->sprite_offset[1][1]= ( (-r*sprite_ref[0][1] + virtual_ref[0][1])*(-2*vop_ref[0][0] + 1) |
753 | 5382 +(-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][1] + 1) |
2967 | 5383 +2*w2*r*sprite_ref[0][1] |
753 | 5384 - 16*w2 |
5385 + (1<<(alpha+rho+1))); | |
5386 s->sprite_delta[0][0]= (-r*sprite_ref[0][0] + virtual_ref[0][0]); | |
5387 s->sprite_delta[0][1]= (+r*sprite_ref[0][1] - virtual_ref[0][1]); | |
5388 s->sprite_delta[1][0]= (-r*sprite_ref[0][1] + virtual_ref[0][1]); | |
5389 s->sprite_delta[1][1]= (-r*sprite_ref[0][0] + virtual_ref[0][0]); | |
2967 | 5390 |
753 | 5391 s->sprite_shift[0]= alpha+rho; |
5392 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
|
5393 break; |
753 | 5394 case 3: |
847 | 5395 min_ab= FFMIN(alpha, beta); |
753 | 5396 w3= w2>>min_ab; |
5397 h3= h2>>min_ab; | |
5398 s->sprite_offset[0][0]= (sprite_ref[0][0]<<(alpha+beta+rho-min_ab)) | |
5399 + (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3*(-vop_ref[0][0]) | |
5400 + (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3*(-vop_ref[0][1]) | |
5401 + (1<<(alpha+beta+rho-min_ab-1)); | |
5402 s->sprite_offset[0][1]= (sprite_ref[0][1]<<(alpha+beta+rho-min_ab)) | |
5403 + (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3*(-vop_ref[0][0]) | |
5404 + (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3*(-vop_ref[0][1]) | |
5405 + (1<<(alpha+beta+rho-min_ab-1)); | |
5406 s->sprite_offset[1][0]= (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3*(-2*vop_ref[0][0] + 1) | |
5407 + (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3*(-2*vop_ref[0][1] + 1) | |
5408 + 2*w2*h3*r*sprite_ref[0][0] | |
5409 - 16*w2*h3 | |
5410 + (1<<(alpha+beta+rho-min_ab+1)); | |
5411 s->sprite_offset[1][1]= (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3*(-2*vop_ref[0][0] + 1) | |
5412 + (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3*(-2*vop_ref[0][1] + 1) | |
5413 + 2*w2*h3*r*sprite_ref[0][1] | |
5414 - 16*w2*h3 | |
5415 + (1<<(alpha+beta+rho-min_ab+1)); | |
5416 s->sprite_delta[0][0]= (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3; | |
5417 s->sprite_delta[0][1]= (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3; | |
5418 s->sprite_delta[1][0]= (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3; | |
5419 s->sprite_delta[1][1]= (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3; | |
2967 | 5420 |
753 | 5421 s->sprite_shift[0]= alpha + beta + rho - min_ab; |
5422 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
|
5423 break; |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5424 } |
2967 | 5425 /* try to simplify the situation */ |
753 | 5426 if( s->sprite_delta[0][0] == a<<s->sprite_shift[0] |
5427 && s->sprite_delta[0][1] == 0 | |
5428 && s->sprite_delta[1][0] == 0 | |
5429 && s->sprite_delta[1][1] == a<<s->sprite_shift[0]) | |
255 | 5430 { |
753 | 5431 s->sprite_offset[0][0]>>=s->sprite_shift[0]; |
5432 s->sprite_offset[0][1]>>=s->sprite_shift[0]; | |
5433 s->sprite_offset[1][0]>>=s->sprite_shift[1]; | |
5434 s->sprite_offset[1][1]>>=s->sprite_shift[1]; | |
5435 s->sprite_delta[0][0]= a; | |
5436 s->sprite_delta[0][1]= 0; | |
5437 s->sprite_delta[1][0]= 0; | |
5438 s->sprite_delta[1][1]= a; | |
5439 s->sprite_shift[0]= 0; | |
5440 s->sprite_shift[1]= 0; | |
255 | 5441 s->real_sprite_warping_points=1; |
5442 } | |
753 | 5443 else{ |
5444 int shift_y= 16 - s->sprite_shift[0]; | |
5445 int shift_c= 16 - s->sprite_shift[1]; | |
5446 for(i=0; i<2; i++){ | |
5447 s->sprite_offset[0][i]<<= shift_y; | |
5448 s->sprite_offset[1][i]<<= shift_c; | |
5449 s->sprite_delta[0][i]<<= shift_y; | |
5450 s->sprite_delta[1][i]<<= shift_y; | |
5451 s->sprite_shift[i]= 16; | |
5452 } | |
255 | 5453 s->real_sprite_warping_points= s->num_sprite_warping_points; |
753 | 5454 } |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5455 } |
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5456 |
942 | 5457 static int mpeg4_decode_gop_header(MpegEncContext * s, GetBitContext *gb){ |
5458 int hours, minutes, seconds; | |
5459 | |
5460 hours= get_bits(gb, 5); | |
5461 minutes= get_bits(gb, 6); | |
5462 skip_bits1(gb); | |
5463 seconds= get_bits(gb, 6); | |
5464 | |
5465 s->time_base= seconds + 60*(minutes + 60*hours); | |
5466 | |
5467 skip_bits1(gb); | |
5468 skip_bits1(gb); | |
2967 | 5469 |
942 | 5470 return 0; |
5471 } | |
5472 | |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5473 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
|
5474 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
|
5475 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5476 /* vol header */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5477 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
|
5478 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
|
5479 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
|
5480 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
|
5481 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
|
5482 } else { |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5483 vo_ver_id = 1; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5484 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5485 s->aspect_ratio_info= get_bits(gb, 4); |
2967 | 5486 if(s->aspect_ratio_info == FF_ASPECT_EXTENDED){ |
1548 | 5487 s->avctx->sample_aspect_ratio.num= get_bits(gb, 8); // par_width |
5488 s->avctx->sample_aspect_ratio.den= get_bits(gb, 8); // par_height | |
887 | 5489 }else{ |
1548 | 5490 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
|
5491 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5492 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5493 if ((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
|
5494 int chroma_format= get_bits(gb, 2); |
8690 | 5495 if(chroma_format!=CHROMA_420){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5496 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
|
5497 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5498 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
|
5499 if(get_bits1(gb)){ /* vbv parameters */ |
2979 | 5500 get_bits(gb, 15); /* first_half_bitrate */ |
5501 skip_bits1(gb); /* marker */ | |
5502 get_bits(gb, 15); /* latter_half_bitrate */ | |
5503 skip_bits1(gb); /* marker */ | |
5504 get_bits(gb, 15); /* first_half_vbv_buffer_size */ | |
5505 skip_bits1(gb); /* marker */ | |
5506 get_bits(gb, 3); /* latter_half_vbv_buffer_size */ | |
5507 get_bits(gb, 11); /* first_half_vbv_occupancy */ | |
5508 skip_bits1(gb); /* marker */ | |
5509 get_bits(gb, 15); /* latter_half_vbv_occupancy */ | |
5510 skip_bits1(gb); /* marker */ | |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5511 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5512 }else{ |
2646
c735e3e60ca7
Even More spelling errors. patch by (Kevin Baragona <kevinmb500 gawab com)
michael
parents:
2639
diff
changeset
|
5513 // 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
|
5514 if(s->picture_number==0) |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5515 s->low_delay=0; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5516 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5517 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5518 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
|
5519 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
|
5520 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
|
5521 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
|
5522 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
|
5523 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5524 |
1411 | 5525 check_marker(gb, "before time_increment_resolution"); |
2967 | 5526 |
2637 | 5527 s->avctx->time_base.den = get_bits(gb, 16); |
2812 | 5528 if(!s->avctx->time_base.den){ |
5529 av_log(s->avctx, AV_LOG_ERROR, "time_base.den==0\n"); | |
5530 return -1; | |
5531 } | |
2967 | 5532 |
2637 | 5533 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
|
5534 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
|
5535 s->time_increment_bits = 1; |
2967 | 5536 |
1411 | 5537 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
|
5538 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5539 if (get_bits1(gb) != 0) { /* fixed_vop_rate */ |
2637 | 5540 s->avctx->time_base.num = get_bits(gb, s->time_increment_bits); |
5541 }else | |
5542 s->avctx->time_base.num = 1; | |
5543 | |
2034 | 5544 s->t_frame=0; |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5545 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5546 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
|
5547 if (s->shape == RECT_SHAPE) { |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5548 skip_bits1(gb); /* marker */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5549 width = get_bits(gb, 13); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5550 skip_bits1(gb); /* marker */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5551 height = get_bits(gb, 13); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5552 skip_bits1(gb); /* marker */ |
8612 | 5553 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
|
5554 s->width = width; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5555 s->height = height; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5556 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5557 } |
2967 | 5558 |
5559 s->progressive_sequence= | |
1659 | 5560 s->progressive_frame= get_bits1(gb)^1; |
3192 | 5561 s->interlaced_dct=0; |
2967 | 5562 if(!get_bits1(gb) && (s->avctx->debug & FF_DEBUG_PICT_INFO)) |
1644 | 5563 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
|
5564 if (vo_ver_id == 1) { |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5565 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
|
5566 } else { |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5567 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
|
5568 } |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5569 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
|
5570 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
|
5571 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
|
5572 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
|
5573 skip_bits1(gb); /* marker */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5574 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
|
5575 skip_bits1(gb); /* marker */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5576 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
|
5577 skip_bits1(gb); /* marker */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5578 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
|
5579 skip_bits1(gb); /* marker */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5580 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5581 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
|
5582 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
|
5583 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
|
5584 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
|
5585 return -1; |
655d25351bfc
fix possibly exploitable stack overflow with num_sprite_warping_points (found by reimar)
michael
parents:
4672
diff
changeset
|
5586 } |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5587 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
|
5588 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
|
5589 if(s->vol_sprite_usage==STATIC_SPRITE) |
2967 | 5590 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
|
5591 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5592 // FIXME sadct disable bit if verid!=1 && shape not rect |
2967 | 5593 |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5594 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
|
5595 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
|
5596 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
|
5597 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
|
5598 } else { |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5599 s->quant_precision = 5; |
0 | 5600 } |
2967 | 5601 |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5602 // 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
|
5603 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5604 if((s->mpeg_quant=get_bits1(gb))){ /* vol_quant_type */ |
1057 | 5605 int i, v; |
2967 | 5606 |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5607 /* load default matrixes */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5608 for(i=0; i<64; i++){ |
1092 | 5609 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
|
5610 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
|
5611 s->intra_matrix[j]= v; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5612 s->chroma_intra_matrix[j]= v; |
2967 | 5613 |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5614 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
|
5615 s->inter_matrix[j]= v; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5616 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
|
5617 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5618 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5619 /* load custom intra matrix */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5620 if(get_bits1(gb)){ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5621 int last=0; |
2979 | 5622 for(i=0; i<64; i++){ |
1057 | 5623 int j; |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5624 v= get_bits(gb, 8); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5625 if(v==0) break; |
2967 | 5626 |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5627 last= v; |
1092 | 5628 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
|
5629 s->intra_matrix[j]= v; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5630 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
|
5631 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5632 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5633 /* replicate last value */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5634 for(; i<64; i++){ |
2979 | 5635 int j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ]; |
1411 | 5636 s->intra_matrix[j]= last; |
5637 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
|
5638 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5639 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5640 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5641 /* load custom non intra matrix */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5642 if(get_bits1(gb)){ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5643 int last=0; |
2979 | 5644 for(i=0; i<64; i++){ |
1057 | 5645 int j; |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5646 v= get_bits(gb, 8); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5647 if(v==0) break; |
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 last= v; |
1092 | 5650 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
|
5651 s->inter_matrix[j]= v; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5652 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
|
5653 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5654 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5655 /* replicate last value */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5656 for(; i<64; i++){ |
2979 | 5657 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
|
5658 s->inter_matrix[j]= last; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5659 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
|
5660 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5661 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5662 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5663 // 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
|
5664 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5665 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5666 if(vo_ver_id != 1) |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5667 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
|
5668 else s->quarter_sample=0; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5669 |
8251
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5670 if(!get_bits1(gb)){ |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5671 int pos= get_bits_count(gb); |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5672 int estimation_method= get_bits(gb, 2); |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5673 if(estimation_method<2){ |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5674 if(!get_bits1(gb)){ |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5675 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
|
5676 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
|
5677 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
|
5678 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
|
5679 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
|
5680 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
|
5681 } |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5682 if(!get_bits1(gb)){ |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5683 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
|
5684 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
|
5685 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
|
5686 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
|
5687 } |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5688 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
|
5689 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
|
5690 goto no_cplx_est; |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5691 } |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5692 if(!get_bits1(gb)){ |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5693 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
|
5694 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
|
5695 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
|
5696 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
|
5697 } |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5698 if(!get_bits1(gb)){ |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5699 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
|
5700 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
|
5701 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
|
5702 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
|
5703 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
|
5704 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
|
5705 } |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5706 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
|
5707 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
|
5708 goto no_cplx_est; |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5709 } |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5710 if(estimation_method==1){ |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5711 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
|
5712 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
|
5713 } |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5714 }else |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5715 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
|
5716 }else{ |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5717 no_cplx_est: |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5718 s->cplx_estimation_trash_i= |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5719 s->cplx_estimation_trash_p= |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5720 s->cplx_estimation_trash_b= 0; |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5721 } |
747
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 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
|
5724 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5725 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
|
5726 if(s->data_partitioning){ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5727 s->rvlc= get_bits1(gb); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5728 } |
2967 | 5729 |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5730 if(vo_ver_id != 1) { |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5731 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
|
5732 if(s->new_pred){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5733 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
|
5734 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
|
5735 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
|
5736 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5737 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
|
5738 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
|
5739 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5740 else{ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5741 s->new_pred=0; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5742 s->reduced_res_vop= 0; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5743 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5744 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5745 s->scalability= get_bits1(gb); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5746 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5747 if (s->scalability) { |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5748 GetBitContext bak= *gb; |
751 | 5749 int ref_layer_id; |
5750 int ref_layer_sampling_dir; | |
5751 int h_sampling_factor_n; | |
5752 int h_sampling_factor_m; | |
5753 int v_sampling_factor_n; | |
5754 int v_sampling_factor_m; | |
2967 | 5755 |
751 | 5756 s->hierachy_type= get_bits1(gb); |
5757 ref_layer_id= get_bits(gb, 4); | |
5758 ref_layer_sampling_dir= get_bits1(gb); | |
5759 h_sampling_factor_n= get_bits(gb, 5); | |
5760 h_sampling_factor_m= get_bits(gb, 5); | |
5761 v_sampling_factor_n= get_bits(gb, 5); | |
5762 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
|
5763 s->enhancement_type= get_bits1(gb); |
2967 | 5764 |
5765 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
|
5766 || v_sampling_factor_n==0 || v_sampling_factor_m==0){ |
2967 | 5767 |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5768 s->scalability=0; |
2967 | 5769 |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5770 *gb= bak; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5771 }else |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5772 av_log(s->avctx, AV_LOG_ERROR, "scalability not supported\n"); |
2967 | 5773 |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5774 // bin shape stuff FIXME |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5775 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5776 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5777 return 0; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5778 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5779 |
1034 | 5780 /** |
5781 * decodes the user data stuff in the header. | |
6918 | 5782 * Also initializes divx/xvid/lavc_version/build. |
1034 | 5783 */ |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5784 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
|
5785 char buf[256]; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5786 int i; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5787 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
|
5788 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
|
5789 char last; |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5790 |
3615 | 5791 for(i=0; i<255 && get_bits_count(gb) < gb->size_in_bits; i++){ |
2804 | 5792 if(show_bits(gb, 23) == 0) break; |
5793 buf[i]= get_bits(gb, 8); | |
5794 } | |
5795 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
|
5796 |
761 | 5797 /* 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
|
5798 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
|
5799 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
|
5800 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
|
5801 if(e>=2){ |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5802 s->divx_version= ver; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5803 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
|
5804 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
|
5805 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
|
5806 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
|
5807 s->showed_packed_warning=1; |
2f5101a67500
Only warn about "Invalid and inefficient vfw-avi packed B frames" once.
andoma
parents:
8042
diff
changeset
|
5808 } |
0 | 5809 } |
2967 | 5810 |
761 | 5811 /* ffmpeg detection */ |
2805
55a6659fc2ee
fix user data parsing code so it suppors pre1 and cvs
michael
parents:
2804
diff
changeset
|
5812 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
|
5813 if(e!=4) |
2967 | 5814 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
|
5815 if(e!=4){ |
2814 | 5816 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
|
5817 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
|
5818 build= (ver<<16) + (ver2<<8) + ver3; |
2814 | 5819 } |
5820 if(e!=4){ | |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5821 if(strcmp(buf, "ffmpeg")==0){ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5822 s->lavc_build= 4600; |
63 | 5823 } |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5824 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5825 if(e==4){ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5826 s->lavc_build= build; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5827 } |
2967 | 5828 |
6908 | 5829 /* Xvid detection */ |
761 | 5830 e=sscanf(buf, "XviD%d", &build); |
5831 if(e==1){ | |
5832 s->xvid_build= build; | |
5833 } | |
5834 | |
747
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 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5838 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
|
5839 int time_incr, time_increment; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5840 |
6481 | 5841 s->pict_type = get_bits(gb, 2) + FF_I_TYPE; /* pict type: I = 0 , P = 1 */ |
5842 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
|
5843 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
|
5844 s->low_delay=0; |
fdeec2834c79
there are divx5? encoded files without a userdata section but with b-frames :(
michaelni
parents:
364
diff
changeset
|
5845 } |
2967 | 5846 |
6481 | 5847 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
|
5848 if(s->partitioned_frame) |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
5849 s->decode_mb= mpeg4_decode_partitioned_mb; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
718
diff
changeset
|
5850 else |
1649
e6a474a5b929
split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents:
1646
diff
changeset
|
5851 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
|
5852 |
262 | 5853 time_incr=0; |
2967 | 5854 while (get_bits1(gb) != 0) |
0 | 5855 time_incr++; |
5856 | |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5857 check_marker(gb, "before time_increment"); |
2666 | 5858 |
5859 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
|
5860 av_log(s->avctx, AV_LOG_ERROR, "hmm, seems the headers are not complete, trying to guess time_increment_bits\n"); |
1068 | 5861 |
5862 for(s->time_increment_bits=1 ;s->time_increment_bits<16; s->time_increment_bits++){ | |
10664 | 5863 if ( s->pict_type == FF_P_TYPE |
5864 || (s->pict_type == FF_S_TYPE && s->vol_sprite_usage==GMC_SPRITE)) { | |
5865 if((show_bits(gb, s->time_increment_bits+6)&0x37) == 0x30) break; | |
5866 }else | |
5867 if((show_bits(gb, s->time_increment_bits+5)&0x1F) == 0x18) break; | |
1068 | 5868 } |
1396 | 5869 |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5870 av_log(s->avctx, AV_LOG_ERROR, "my guess is %d bits ;)\n",s->time_increment_bits); |
1068 | 5871 } |
2967 | 5872 |
1411 | 5873 if(IS_3IV1) time_increment= get_bits1(gb); //FIXME investigate further |
5874 else time_increment= get_bits(gb, s->time_increment_bits); | |
2967 | 5875 |
6481 | 5876 if(s->pict_type!=FF_B_TYPE){ |
324 | 5877 s->last_time_base= s->time_base; |
262 | 5878 s->time_base+= time_incr; |
2637 | 5879 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
|
5880 if(s->workaround_bugs&FF_BUG_UMP4){ |
700
0fb4c66527e1
autodetect UMP4 (by adding a fourcc field to AVCodecContext)
michaelni
parents:
699
diff
changeset
|
5881 if(s->time < s->last_non_b_time){ |
0fb4c66527e1
autodetect UMP4 (by adding a fourcc field to AVCodecContext)
michaelni
parents:
699
diff
changeset
|
5882 s->time_base++; |
2637 | 5883 s->time+= s->avctx->time_base.den; |
700
0fb4c66527e1
autodetect UMP4 (by adding a fourcc field to AVCodecContext)
michaelni
parents:
699
diff
changeset
|
5884 } |
664 | 5885 } |
324 | 5886 s->pp_time= s->time - s->last_non_b_time; |
5887 s->last_non_b_time= s->time; | |
262 | 5888 }else{ |
2637 | 5889 s->time= (s->last_time_base + time_incr)*s->avctx->time_base.den + time_increment; |
664 | 5890 s->pb_time= s->pp_time - (s->last_non_b_time - s->time); |
5891 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
|
5892 return FRAME_SKIPPED; |
335 | 5893 } |
3247 | 5894 ff_mpeg4_init_direct_mv(s); |
2967 | 5895 |
2034 | 5896 if(s->t_frame==0) s->t_frame= s->pb_time; |
664 | 5897 if(s->t_frame==0) s->t_frame=1; // 1/0 protection |
2967 | 5898 s->pp_field_time= ( ROUNDED_DIV(s->last_non_b_time, s->t_frame) |
664 | 5899 - ROUNDED_DIV(s->last_non_b_time - s->pp_time, s->t_frame))*2; |
2967 | 5900 s->pb_field_time= ( ROUNDED_DIV(s->time, s->t_frame) |
664 | 5901 - ROUNDED_DIV(s->last_non_b_time - s->pp_time, s->t_frame))*2; |
4346 | 5902 if(!s->progressive_sequence){ |
5903 if(s->pp_field_time <= s->pb_field_time || s->pb_field_time <= 1) | |
5904 return FRAME_SKIPPED; | |
5905 } | |
262 | 5906 } |
2967 | 5907 |
2813
6fd9dbb8c385
try to check for nonsense time_base instead of setting fake one
michael
parents:
2812
diff
changeset
|
5908 if(s->avctx->time_base.num) |
6fd9dbb8c385
try to check for nonsense time_base instead of setting fake one
michael
parents:
2812
diff
changeset
|
5909 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
|
5910 else |
6fd9dbb8c385
try to check for nonsense time_base instead of setting fake one
michael
parents:
2812
diff
changeset
|
5911 s->current_picture_ptr->pts= AV_NOPTS_VALUE; |
942 | 5912 if(s->avctx->debug&FF_DEBUG_PTS) |
2962 | 5913 av_log(s->avctx, AV_LOG_DEBUG, "MPEG4 PTS: %"PRId64"\n", s->current_picture_ptr->pts); |
2034 | 5914 |
1068 | 5915 check_marker(gb, "before vop_coded"); |
2967 | 5916 |
0 | 5917 /* vop coded */ |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5918 if (get_bits1(gb) != 1){ |
2271 | 5919 if(s->avctx->debug&FF_DEBUG_PICT_INFO) |
5920 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
|
5921 return FRAME_SKIPPED; |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5922 } |
6481 | 5923 if (s->shape != BIN_ONLY_SHAPE && ( s->pict_type == FF_P_TYPE |
5924 || (s->pict_type == FF_S_TYPE && s->vol_sprite_usage==GMC_SPRITE))) { | |
0 | 5925 /* rounding type for motion estimation */ |
2979 | 5926 s->no_rounding = get_bits1(gb); |
63 | 5927 } else { |
2979 | 5928 s->no_rounding = 0; |
0 | 5929 } |
253
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
5930 //FIXME reduced res stuff |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
5931 |
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
5932 if (s->shape != RECT_SHAPE) { |
6481 | 5933 if (s->vol_sprite_usage != 1 || s->pict_type != FF_I_TYPE) { |
63 | 5934 int width, height, hor_spat_ref, ver_spat_ref; |
2967 | 5935 |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5936 width = get_bits(gb, 13); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5937 skip_bits1(gb); /* marker */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5938 height = get_bits(gb, 13); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5939 skip_bits1(gb); /* marker */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5940 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
|
5941 skip_bits1(gb); /* marker */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5942 ver_spat_ref = get_bits(gb, 13); /* ver_spat_ref */ |
63 | 5943 } |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5944 skip_bits1(gb); /* change_CR_disable */ |
2967 | 5945 |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5946 if (get_bits1(gb) != 0) { |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5947 skip_bits(gb, 8); /* constant_alpha_value */ |
63 | 5948 } |
5949 } | |
253
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
5950 //FIXME complexity estimation stuff |
2967 | 5951 |
253
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
5952 if (s->shape != BIN_ONLY_SHAPE) { |
8251
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5953 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
|
5954 if(s->pict_type != FF_I_TYPE) |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5955 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
|
5956 if(s->pict_type == FF_B_TYPE) |
d256dbf74ea6
Implement complexity estimation parsing and try to detect an incorrectly set
michael
parents:
8106
diff
changeset
|
5957 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
|
5958 |
1520 | 5959 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
|
5960 if(!s->progressive_sequence){ |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
5961 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
|
5962 s->alternate_scan= get_bits1(gb); |
661 | 5963 }else |
5964 s->alternate_scan= 0; | |
253
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
5965 } |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5966 |
718 | 5967 if(s->alternate_scan){ |
1273 | 5968 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_alternate_vertical_scan); |
5969 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_alternate_vertical_scan); | |
5970 ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_vertical_scan); | |
5971 ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan); | |
718 | 5972 } else{ |
1273 | 5973 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_zigzag_direct); |
5974 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_zigzag_direct); | |
5975 ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan); | |
5976 ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan); | |
718 | 5977 } |
2967 | 5978 |
6481 | 5979 if(s->pict_type == FF_S_TYPE && (s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE)){ |
1914 | 5980 mpeg4_decode_sprite_trajectory(s, gb); |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5981 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
|
5982 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
|
5983 } |
254
b4fed8b24e3a
gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents:
253
diff
changeset
|
5984 |
253
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
5985 if (s->shape != BIN_ONLY_SHAPE) { |
1644 | 5986 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
|
5987 if(s->qscale==0){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5988 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
|
5989 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
|
5990 } |
2967 | 5991 |
6481 | 5992 if (s->pict_type != FF_I_TYPE) { |
2979 | 5993 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
|
5994 if(s->f_code==0){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
5995 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
|
5996 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
|
5997 } |
582
5132a4ee50cd
different edge positions fixed with edge emu / dr1
michaelni
parents:
575
diff
changeset
|
5998 }else |
5132a4ee50cd
different edge positions fixed with edge emu / dr1
michaelni
parents:
575
diff
changeset
|
5999 s->f_code=1; |
2967 | 6000 |
6481 | 6001 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
|
6002 s->b_code = get_bits(gb, 3); |
582
5132a4ee50cd
different edge positions fixed with edge emu / dr1
michaelni
parents:
575
diff
changeset
|
6003 }else |
5132a4ee50cd
different edge positions fixed with edge emu / dr1
michaelni
parents:
575
diff
changeset
|
6004 s->b_code=1; |
906 | 6005 |
6006 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
|
6007 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 | 6008 s->qscale, s->f_code, s->b_code, |
6481 | 6009 s->pict_type == FF_I_TYPE ? "I" : (s->pict_type == FF_P_TYPE ? "P" : (s->pict_type == FF_B_TYPE ? "B" : "S")), |
2967 | 6010 gb->size_in_bits,s->progressive_sequence, s->alternate_scan, s->top_field_first, |
930 | 6011 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
|
6012 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 | 6013 } |
6014 | |
253
4448dd55d415
parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents:
250
diff
changeset
|
6015 if(!s->scalability){ |
6481 | 6016 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
|
6017 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
|
6018 } |
575 | 6019 }else{ |
6020 if(s->enhancement_type){ | |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6021 int load_backward_shape= get_bits1(gb); |
575 | 6022 if(load_backward_shape){ |
2646
c735e3e60ca7
Even More spelling errors. patch by (Kevin Baragona <kevinmb500 gawab com)
michael
parents:
2639
diff
changeset
|
6023 av_log(s->avctx, AV_LOG_ERROR, "load backward shape isn't supported\n"); |
575 | 6024 } |
6025 } | |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6026 skip_bits(gb, 2); //ref_select_code |
63 | 6027 } |
6028 } | |
2646
c735e3e60ca7
Even More spelling errors. patch by (Kevin Baragona <kevinmb500 gawab com)
michael
parents:
2639
diff
changeset
|
6029 /* 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
|
6030 // 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
|
6031 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
|
6032 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
|
6033 s->low_delay=1; |
c2f789fe4945
detecting xvid/divx4/opendivx and set low_delay flag
michaelni
parents:
344
diff
changeset
|
6034 } |
c2f789fe4945
detecting xvid/divx4/opendivx and set low_delay flag
michaelni
parents:
344
diff
changeset
|
6035 |
2646
c735e3e60ca7
Even More spelling errors. patch by (Kevin Baragona <kevinmb500 gawab com)
michael
parents:
2639
diff
changeset
|
6036 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
|
6037 |
2967 | 6038 s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table; //FIXME add short header support |
498 | 6039 s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table; |
6040 | |
1366
80067f8d6770
fix edge repeating bug for %16!=0 files, this fixes Quicktime mpeg4 (they arent buggy)
michaelni
parents:
1364
diff
changeset
|
6041 if(s->workaround_bugs&FF_BUG_EDGE){ |
582
5132a4ee50cd
different edge positions fixed with edge emu / dr1
michaelni
parents:
575
diff
changeset
|
6042 s->h_edge_pos= s->width; |
5132a4ee50cd
different edge positions fixed with edge emu / dr1
michaelni
parents:
575
diff
changeset
|
6043 s->v_edge_pos= s->height; |
5132a4ee50cd
different edge positions fixed with edge emu / dr1
michaelni
parents:
575
diff
changeset
|
6044 } |
63 | 6045 return 0; |
0 | 6046 } |
6047 | |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6048 /** |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6049 * decode mpeg4 headers |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6050 * @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
|
6051 * 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
|
6052 * 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
|
6053 */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6054 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
|
6055 { |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6056 int startcode, v; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6057 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6058 /* search next start code */ |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6059 align_get_bits(gb); |
2406 | 6060 |
8612 | 6061 if(s->codec_tag == AV_RL32("WV1F") && show_bits(gb, 24) == 0x575630){ |
2406 | 6062 skip_bits(gb, 24); |
6063 if(get_bits(gb, 8) == 0xF0) | |
8417
ad4f10287633
Move CODEC_FLAG_LOW_DELAY into ff_mpeg4_decode_picture_header().
michael
parents:
8297
diff
changeset
|
6064 goto end; |
2406 | 6065 } |
6066 | |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6067 startcode = 0xff; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6068 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
|
6069 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
|
6070 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
|
6071 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
|
6072 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
|
6073 }else |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6074 return -1; //end of stream |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6075 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6076 |
2966
564788471dd4
bitstream related fixes from [PATCH] from DivX, Part 9: bitstream crashes by (Steve Lhomme | slhomme divxcorp com)
michael
parents:
2962
diff
changeset
|
6077 /* 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
|
6078 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
|
6079 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
|
6080 |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6081 if((startcode&0xFFFFFF00) != 0x100) |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6082 continue; //no startcode |
2967 | 6083 |
942 | 6084 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
|
6085 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
|
6086 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
|
6087 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
|
6088 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
|
6089 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
|
6090 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
|
6091 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
|
6092 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
|
6093 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
|
6094 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
|
6095 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
|
6096 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
|
6097 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
|
6098 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
|
6099 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
|
6100 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
|
6101 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
|
6102 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
|
6103 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
|
6104 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
|
6105 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
|
6106 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
|
6107 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
|
6108 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
|
6109 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
|
6110 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
|
6111 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
|
6112 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
|
6113 av_log(s->avctx, AV_LOG_DEBUG, " at %d\n", get_bits_count(gb)); |
942 | 6114 } |
6115 | |
1512 | 6116 if(startcode >= 0x120 && startcode <= 0x12F){ |
2967 | 6117 if(decode_vol_header(s, gb) < 0) |
1396 | 6118 return -1; |
1512 | 6119 } |
6120 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
|
6121 decode_user_data(s, gb); |
1512 | 6122 } |
6123 else if(startcode == GOP_STARTCODE){ | |
942 | 6124 mpeg4_decode_gop_header(s, gb); |
1512 | 6125 } |
6126 else if(startcode == VOP_STARTCODE){ | |
8417
ad4f10287633
Move CODEC_FLAG_LOW_DELAY into ff_mpeg4_decode_picture_header().
michael
parents:
8297
diff
changeset
|
6127 break; |
747
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6128 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6129 |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6130 align_get_bits(gb); |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6131 startcode = 0xff; |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6132 } |
8417
ad4f10287633
Move CODEC_FLAG_LOW_DELAY into ff_mpeg4_decode_picture_header().
michael
parents:
8297
diff
changeset
|
6133 end: |
ad4f10287633
Move CODEC_FLAG_LOW_DELAY into ff_mpeg4_decode_picture_header().
michael
parents:
8297
diff
changeset
|
6134 if(s->flags& CODEC_FLAG_LOW_DELAY) |
ad4f10287633
Move CODEC_FLAG_LOW_DELAY into ff_mpeg4_decode_picture_header().
michael
parents:
8297
diff
changeset
|
6135 s->low_delay=1; |
8418
f75be04312dc
Fix PTS returned by the demuxers for mpeg4 without a decoder.
michael
parents:
8417
diff
changeset
|
6136 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
|
6137 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
|
6138 } |
3d4377531f6c
mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents:
745
diff
changeset
|
6139 |
0 | 6140 /* don't understand why they choose a different header ! */ |
6141 int intel_h263_decode_picture_header(MpegEncContext *s) | |
6142 { | |
6143 int format; | |
6144 | |
6145 /* picture header */ | |
1257 | 6146 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
|
6147 av_log(s->avctx, AV_LOG_ERROR, "Bad picture start code\n"); |
0 | 6148 return -1; |
355 | 6149 } |
6150 s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */ | |
0 | 6151 |
355 | 6152 if (get_bits1(&s->gb) != 1) { |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
6153 av_log(s->avctx, AV_LOG_ERROR, "Bad marker\n"); |
2979 | 6154 return -1; /* marker */ |
355 | 6155 } |
6156 if (get_bits1(&s->gb) != 0) { | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
6157 av_log(s->avctx, AV_LOG_ERROR, "Bad H263 id\n"); |
2979 | 6158 return -1; /* h263 id */ |
6159 } | |
6160 skip_bits1(&s->gb); /* split screen off */ | |
6161 skip_bits1(&s->gb); /* camera off */ | |
6162 skip_bits1(&s->gb); /* freeze picture release off */ | |
0 | 6163 |
6164 format = get_bits(&s->gb, 3); | |
355 | 6165 if (format != 7) { |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
6166 av_log(s->avctx, AV_LOG_ERROR, "Intel H263 free format not supported\n"); |
0 | 6167 return -1; |
355 | 6168 } |
0 | 6169 s->h263_plus = 0; |
6170 | |
6481 | 6171 s->pict_type = FF_I_TYPE + get_bits1(&s->gb); |
2967 | 6172 |
6173 s->unrestricted_mv = get_bits1(&s->gb); | |
0 | 6174 s->h263_long_vectors = s->unrestricted_mv; |
6175 | |
355 | 6176 if (get_bits1(&s->gb) != 0) { |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
6177 av_log(s->avctx, AV_LOG_ERROR, "SAC not supported\n"); |
2979 | 6178 return -1; /* SAC: off */ |
355 | 6179 } |
5405
f15e5b4909e1
remove "Advanced Prediction Mode not supported" spam
michael
parents:
5404
diff
changeset
|
6180 s->obmc= get_bits1(&s->gb); |
9008 | 6181 s->pb_frame = get_bits1(&s->gb); |
6182 | |
6183 if(format == 7){ | |
6184 format = get_bits(&s->gb, 3); | |
6185 if(format == 0 || format == 7){ | |
6186 av_log(s->avctx, AV_LOG_ERROR, "Wrong Intel H263 format\n"); | |
6187 return -1; | |
6188 } | |
6189 if(get_bits(&s->gb, 2)) | |
6190 av_log(s->avctx, AV_LOG_ERROR, "Bad value for reserved field\n"); | |
6191 s->loop_filter = get_bits1(&s->gb); | |
6192 if(get_bits1(&s->gb)) | |
6193 av_log(s->avctx, AV_LOG_ERROR, "Bad value for reserved field\n"); | |
6194 if(get_bits1(&s->gb)) | |
6195 s->pb_frame = 2; | |
6196 if(get_bits(&s->gb, 5)) | |
6197 av_log(s->avctx, AV_LOG_ERROR, "Bad value for reserved field\n"); | |
6198 if(get_bits(&s->gb, 5) != 1) | |
6199 av_log(s->avctx, AV_LOG_ERROR, "Invalid marker\n"); | |
6200 } | |
6201 if(format == 6){ | |
6202 int ar = get_bits(&s->gb, 4); | |
6203 skip_bits(&s->gb, 9); // display width | |
6204 skip_bits1(&s->gb); | |
6205 skip_bits(&s->gb, 9); // display height | |
6206 if(ar == 15){ | |
6207 skip_bits(&s->gb, 8); // aspect ratio - width | |
6208 skip_bits(&s->gb, 8); // aspect ratio - height | |
6209 } | |
6210 } | |
0 | 6211 |
1644 | 6212 s->chroma_qscale= s->qscale = get_bits(&s->gb, 5); |
2979 | 6213 skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */ |
0 | 6214 |
9008 | 6215 if(s->pb_frame){ |
6216 skip_bits(&s->gb, 3); //temporal reference for B-frame | |
6217 skip_bits(&s->gb, 2); //dbquant | |
6218 } | |
6219 | |
0 | 6220 /* PEI */ |
21 | 6221 while (get_bits1(&s->gb) != 0) { |
6222 skip_bits(&s->gb, 8); | |
0 | 6223 } |
6224 s->f_code = 1; | |
770
d1770a34e4f6
segfault fix patch by (Juergen Keil <jk at tools dot de>)
michaelni
parents:
766
diff
changeset
|
6225 |
d1770a34e4f6
segfault fix patch by (Juergen Keil <jk at tools dot de>)
michaelni
parents:
766
diff
changeset
|
6226 s->y_dc_scale_table= |
d1770a34e4f6
segfault fix patch by (Juergen Keil <jk at tools dot de>)
michaelni
parents:
766
diff
changeset
|
6227 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
|
6228 |
5404 | 6229 if(s->avctx->debug&FF_DEBUG_PICT_INFO) |
6230 show_pict_info(s); | |
6231 | |
0 | 6232 return 0; |
6233 } | |
144 | 6234 |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6235 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
|
6236 { |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6237 int format, width, height; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6238 |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6239 /* picture header */ |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6240 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
|
6241 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
|
6242 return -1; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6243 } |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6244 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
|
6245 if (format != 0 && format != 1) { |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1586
diff
changeset
|
6246 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
|
6247 return -1; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6248 } |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6249 s->h263_flv = format+1; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6250 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
|
6251 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
|
6252 switch (format) { |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6253 case 0: |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6254 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
|
6255 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
|
6256 break; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6257 case 1: |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6258 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
|
6259 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
|
6260 break; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6261 case 2: |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6262 width = 352; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6263 height = 288; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6264 break; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6265 case 3: |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6266 width = 176; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6267 height = 144; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6268 break; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6269 case 4: |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6270 width = 128; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6271 height = 96; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6272 break; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6273 case 5: |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6274 width = 320; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6275 height = 240; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6276 break; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6277 case 6: |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6278 width = 160; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6279 height = 120; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6280 break; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6281 default: |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6282 width = height = 0; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6283 break; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6284 } |
2422 | 6285 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
|
6286 return -1; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6287 s->width = width; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6288 s->height = height; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6289 |
6481 | 6290 s->pict_type = FF_I_TYPE + get_bits(&s->gb, 2); |
6291 s->dropable= s->pict_type > FF_P_TYPE; | |
1944 | 6292 if (s->dropable) |
6481 | 6293 s->pict_type = FF_P_TYPE; |
2967 | 6294 |
2979 | 6295 skip_bits1(&s->gb); /* deblocking flag */ |
1644 | 6296 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
|
6297 |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6298 s->h263_plus = 0; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6299 |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6300 s->unrestricted_mv = 1; |
1364 | 6301 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
|
6302 |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6303 /* PEI */ |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6304 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
|
6305 skip_bits(&s->gb, 8); |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6306 } |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6307 s->f_code = 1; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6308 |
1364 | 6309 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
|
6310 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
|
6311 s->dropable ? 'D' : av_get_pict_type_char(s->pict_type), s->h263_flv-1, s->qscale, s->picture_number); |
1364 | 6312 } |
2967 | 6313 |
1353
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6314 s->y_dc_scale_table= |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6315 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
|
6316 |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6317 return 0; |
cfc80b3a4ada
flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents:
1350
diff
changeset
|
6318 } |