annotate h263.c @ 1708:dea5b2946999 libavcodec

interlaced motion estimation interlaced mpeg2 encoding P & B frames rate distored interlaced mb decission alternate scantable support 4mv encoding fixes (thats also why the regression tests change) passing height to most dsp functions interlaced mpeg4 encoding (no direct mode MBs yet) various related cleanups disabled old motion estimaton algorithms (log, full, ...) they will either be fixed or removed
author michael
date Tue, 30 Dec 2003 16:07:57 +0000
parents 95b7ac3344df
children 07a484280a82
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
rev   line source
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1 /*
986e461dc072 Initial revision
glantau
parents:
diff changeset
2 * H263/MPEG4 backend for ffmpeg encoder and decoder
429
718a22dc121f license/copyright change
glantau
parents: 396
diff changeset
3 * Copyright (c) 2000,2001 Fabrice Bellard.
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
4 * H263+ support.
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
5 * Copyright (c) 2001 Juan J. Sierralta P.
986e461dc072 Initial revision
glantau
parents:
diff changeset
6 *
429
718a22dc121f license/copyright change
glantau
parents: 396
diff changeset
7 * This library is free software; you can redistribute it and/or
718a22dc121f license/copyright change
glantau
parents: 396
diff changeset
8 * modify it under the terms of the GNU Lesser General Public
718a22dc121f license/copyright change
glantau
parents: 396
diff changeset
9 * License as published by the Free Software Foundation; either
718a22dc121f license/copyright change
glantau
parents: 396
diff changeset
10 * version 2 of the License, or (at your option) any later version.
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
11 *
429
718a22dc121f license/copyright change
glantau
parents: 396
diff changeset
12 * This library is distributed in the hope that it will be useful,
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
429
718a22dc121f license/copyright change
glantau
parents: 396
diff changeset
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
718a22dc121f license/copyright change
glantau
parents: 396
diff changeset
15 * Lesser General Public License for more details.
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
16 *
429
718a22dc121f license/copyright change
glantau
parents: 396
diff changeset
17 * You should have received a copy of the GNU Lesser General Public
718a22dc121f license/copyright change
glantau
parents: 396
diff changeset
18 * License along with this library; if not, write to the Free Software
718a22dc121f license/copyright change
glantau
parents: 396
diff changeset
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
277
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
20 *
656
e47fa3e3f2d5 statistics for forw & back p-MBs instead of just one counter for both
michaelni
parents: 654
diff changeset
21 * ac prediction encoding, b-frame support, error resilience, optimizations,
e47fa3e3f2d5 statistics for forw & back p-MBs instead of just one counter for both
michaelni
parents: 654
diff changeset
22 * qpel decoding, gmc decoding, interlaced decoding,
e47fa3e3f2d5 statistics for forw & back p-MBs instead of just one counter for both
michaelni
parents: 654
diff changeset
23 * by Michael Niedermayer <michaelni@gmx.at>
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
24 */
1034
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
25
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
26 /**
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
27 * @file h263.c
1106
1e39f273ecd6 per file doxy
michaelni
parents: 1092
diff changeset
28 * h263/mpeg4 codec.
1034
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
29 */
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
30
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
31 //#define DEBUG
1490
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
32 #include <limits.h>
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
33
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
34 #include "common.h"
986e461dc072 Initial revision
glantau
parents:
diff changeset
35 #include "dsputil.h"
986e461dc072 Initial revision
glantau
parents:
diff changeset
36 #include "avcodec.h"
986e461dc072 Initial revision
glantau
parents:
diff changeset
37 #include "mpegvideo.h"
986e461dc072 Initial revision
glantau
parents:
diff changeset
38 #include "h263data.h"
986e461dc072 Initial revision
glantau
parents:
diff changeset
39 #include "mpeg4data.h"
986e461dc072 Initial revision
glantau
parents:
diff changeset
40
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
41 //#undef NDEBUG
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
42 //#include <assert.h>
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
43
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
44 #define INTRA_MCBPC_VLC_BITS 6
1482
b372ecde32a8 h263 stuffing decode fix
michaelni
parents: 1457
diff changeset
45 #define INTER_MCBPC_VLC_BITS 7
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
46 #define CBPY_VLC_BITS 6
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
47 #define MV_VLC_BITS 9
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
48 #define DC_VLC_BITS 9
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
49 #define SPRITE_TRAJ_VLC_BITS 6
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
50 #define MB_TYPE_B_VLC_BITS 4
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
51 #define TEX_VLC_BITS 9
1655
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
52 #define H263_MBTYPE_B_VLC_BITS 6
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
53 #define CBPC_B_VLC_BITS 3
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
54
815
78accc54493b put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents: 770
diff changeset
55 #ifdef CONFIG_ENCODERS
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
56 static void h263_encode_block(MpegEncContext * s, DCTELEM * block,
1353
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
57 int n);
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
58 static void h263_encode_motion(MpegEncContext * s, int val, int fcode);
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
59 static void h263p_encode_umotion(MpegEncContext * s, int val);
648
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
60 static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block,
1353
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
61 int n, int dc, uint8_t *scan_table,
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
62 PutBitContext *dc_pb, PutBitContext *ac_pb);
815
78accc54493b put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents: 770
diff changeset
63 #endif
78accc54493b put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents: 770
diff changeset
64
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
65 static int h263_decode_motion(MpegEncContext * s, int pred, int fcode);
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
66 static int h263p_decode_umotion(MpegEncContext * s, int pred);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
67 static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
986e461dc072 Initial revision
glantau
parents:
diff changeset
68 int n, int coded);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
69 static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
70 static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
1132
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
71 int n, int coded, int intra, int rvlc);
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
72 static int h263_pred_dc(MpegEncContext * s, int n, uint16_t **dc_val_ptr);
1070
6da5ae9ee199 more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents: 1068
diff changeset
73 #ifdef CONFIG_ENCODERS
1424
39ebefd82728 fixing CODEC_FLAG_GLOBAL_HEADER
michaelni
parents: 1419
diff changeset
74 static void mpeg4_encode_visual_object_header(MpegEncContext * s);
39ebefd82728 fixing CODEC_FLAG_GLOBAL_HEADER
michaelni
parents: 1419
diff changeset
75 static void mpeg4_encode_vol_header(MpegEncContext * s, int vo_number, int vol_number);
1070
6da5ae9ee199 more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents: 1068
diff changeset
76 #endif //CONFIG_ENCODERS
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
77 static void mpeg4_decode_sprite_trajectory(MpegEncContext * s);
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
78 static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, uint16_t **dc_val_ptr, int *dir_ptr);
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
79
1070
6da5ae9ee199 more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents: 1068
diff changeset
80 #ifdef CONFIG_ENCODERS
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
81 static uint8_t uni_DCtab_lum_len[512];
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
82 static uint8_t uni_DCtab_chrom_len[512];
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
83 static uint16_t uni_DCtab_lum_bits[512];
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
84 static uint16_t uni_DCtab_chrom_bits[512];
815
78accc54493b put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents: 770
diff changeset
85
1162
8c15d82c1893 some static -> dynamic alloc & 16->8 bit
michaelni
parents: 1150
diff changeset
86 static uint8_t (*mv_penalty)[MAX_MV*2+1]= NULL;
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
87 static uint8_t fcode_tab[MAX_MV*2+1];
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
88 static uint8_t umv_fcode_tab[MAX_MV*2+1];
815
78accc54493b put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents: 770
diff changeset
89
945
463f7260b155 trellis quantization
michaelni
parents: 942
diff changeset
90 static uint32_t uni_mpeg4_intra_rl_bits[64*64*2*2];
463f7260b155 trellis quantization
michaelni
parents: 942
diff changeset
91 static uint8_t uni_mpeg4_intra_rl_len [64*64*2*2];
463f7260b155 trellis quantization
michaelni
parents: 942
diff changeset
92 static uint32_t uni_mpeg4_inter_rl_bits[64*64*2*2];
463f7260b155 trellis quantization
michaelni
parents: 942
diff changeset
93 static uint8_t uni_mpeg4_inter_rl_len [64*64*2*2];
463f7260b155 trellis quantization
michaelni
parents: 942
diff changeset
94 //#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128 + (run)*256 + (level))
648
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
95 //#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run) + (level)*64)
945
463f7260b155 trellis quantization
michaelni
parents: 942
diff changeset
96 #define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run)*128 + (level))
648
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
97
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
98 /* mpeg4
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
99 inter
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
100 max level: 24/6
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
101 max run: 53/63
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
102
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
103 intra
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
104 max level: 53/16
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
105 max run: 29/41
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
106 */
815
78accc54493b put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents: 770
diff changeset
107 #endif
78accc54493b put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents: 770
diff changeset
108
1271
42ea05e4a391 improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents: 1261
diff changeset
109 #if 0 //3IV1 is quite rare and tis slows things down a tiny bit
42ea05e4a391 improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents: 1261
diff changeset
110 #define IS_3IV1 s->avctx->codec_tag == ff_get_fourcc("3IV1")
42ea05e4a391 improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents: 1261
diff changeset
111 #else
42ea05e4a391 improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents: 1261
diff changeset
112 #define IS_3IV1 0
42ea05e4a391 improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents: 1261
diff changeset
113 #endif
293
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
114
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
115 int h263_get_picture_format(int width, int height)
986e461dc072 Initial revision
glantau
parents:
diff changeset
116 {
986e461dc072 Initial revision
glantau
parents:
diff changeset
117 int format;
986e461dc072 Initial revision
glantau
parents:
diff changeset
118
986e461dc072 Initial revision
glantau
parents:
diff changeset
119 if (width == 128 && height == 96)
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
120 format = 1;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
121 else if (width == 176 && height == 144)
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
122 format = 2;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
123 else if (width == 352 && height == 288)
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
124 format = 3;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
125 else if (width == 704 && height == 576)
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
126 format = 4;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
127 else if (width == 1408 && height == 1152)
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
128 format = 5;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
129 else
986e461dc072 Initial revision
glantau
parents:
diff changeset
130 format = 7;
986e461dc072 Initial revision
glantau
parents:
diff changeset
131 return format;
986e461dc072 Initial revision
glantau
parents:
diff changeset
132 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
133
1070
6da5ae9ee199 more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents: 1068
diff changeset
134 #ifdef CONFIG_ENCODERS
6da5ae9ee199 more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents: 1068
diff changeset
135
1548
dd544554ed42 AVRational
michael
parents: 1542
diff changeset
136 static void aspect_to_info(MpegEncContext * s, AVRational aspect){
887
19f5b8b7c6d5 fixing aspect
michaelni
parents: 880
diff changeset
137 int i;
19f5b8b7c6d5 fixing aspect
michaelni
parents: 880
diff changeset
138
1548
dd544554ed42 AVRational
michael
parents: 1542
diff changeset
139 if(aspect.num==0) aspect= (AVRational){1,1};
dd544554ed42 AVRational
michael
parents: 1542
diff changeset
140
887
19f5b8b7c6d5 fixing aspect
michaelni
parents: 880
diff changeset
141 for(i=1; i<6; i++){
1548
dd544554ed42 AVRational
michael
parents: 1542
diff changeset
142 if(av_cmp_q(pixel_aspect[i], aspect) == 0){
887
19f5b8b7c6d5 fixing aspect
michaelni
parents: 880
diff changeset
143 s->aspect_ratio_info=i;
19f5b8b7c6d5 fixing aspect
michaelni
parents: 880
diff changeset
144 return;
19f5b8b7c6d5 fixing aspect
michaelni
parents: 880
diff changeset
145 }
19f5b8b7c6d5 fixing aspect
michaelni
parents: 880
diff changeset
146 }
880
1c32039e7215 aspect ratio cleanup
michaelni
parents: 853
diff changeset
147
887
19f5b8b7c6d5 fixing aspect
michaelni
parents: 880
diff changeset
148 s->aspect_ratio_info= FF_ASPECT_EXTENDED;
880
1c32039e7215 aspect ratio cleanup
michaelni
parents: 853
diff changeset
149 }
1c32039e7215 aspect ratio cleanup
michaelni
parents: 853
diff changeset
150
1354
1f89adb69349 flv cleanup / simplify
michaelni
parents: 1353
diff changeset
151 void ff_flv_encode_picture_header(MpegEncContext * s, int picture_number)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
152 {
1354
1f89adb69349 flv cleanup / simplify
michaelni
parents: 1353
diff changeset
153 int format;
1f89adb69349 flv cleanup / simplify
michaelni
parents: 1353
diff changeset
154
1f89adb69349 flv cleanup / simplify
michaelni
parents: 1353
diff changeset
155 align_put_bits(&s->pb);
1f89adb69349 flv cleanup / simplify
michaelni
parents: 1353
diff changeset
156
1353
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
157 put_bits(&s->pb, 17, 1);
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
158 put_bits(&s->pb, 5, (s->h263_flv-1)); /* 0: h263 escape codes 1: 11-bit escape codes */
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
159 put_bits(&s->pb, 8, (((int64_t)s->picture_number * 30 * s->avctx->frame_rate_base) /
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
160 s->avctx->frame_rate) & 0xff); /* TemporalReference */
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
161 if (s->width == 352 && s->height == 288)
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
162 format = 2;
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
163 else if (s->width == 176 && s->height == 144)
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
164 format = 3;
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
165 else if (s->width == 128 && s->height == 96)
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
166 format = 4;
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
167 else if (s->width == 320 && s->height == 240)
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
168 format = 5;
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
169 else if (s->width == 160 && s->height == 120)
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
170 format = 6;
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
171 else if (s->width <= 255 && s->height <= 255)
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
172 format = 0; /* use 1 byte width & height */
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
173 else
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
174 format = 1; /* use 2 bytes width & height */
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
175 put_bits(&s->pb, 3, format); /* PictureSize */
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
176 if (format == 0) {
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
177 put_bits(&s->pb, 8, s->width);
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
178 put_bits(&s->pb, 8, s->height);
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
179 } else if (format == 1) {
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
180 put_bits(&s->pb, 16, s->width);
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
181 put_bits(&s->pb, 16, s->height);
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
182 }
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
183 put_bits(&s->pb, 2, s->pict_type == P_TYPE); /* PictureType */
1390
39d07c0263de patch for flv deblocking by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1389
diff changeset
184 put_bits(&s->pb, 1, 1); /* DeblockingFlag: on */
1353
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
185 put_bits(&s->pb, 5, s->qscale); /* Quantizer */
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
186 put_bits(&s->pb, 1, 0); /* ExtraInformation */
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
187
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
188 if(s->h263_aic){
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
189 s->y_dc_scale_table=
1639
3e2b774edce4 rv20 decoder
michael
parents: 1637
diff changeset
190 s->c_dc_scale_table= ff_aic_dc_scale_table;
1353
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
191 }else{
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
192 s->y_dc_scale_table=
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
193 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
194 }
1354
1f89adb69349 flv cleanup / simplify
michaelni
parents: 1353
diff changeset
195 }
1f89adb69349 flv cleanup / simplify
michaelni
parents: 1353
diff changeset
196
1f89adb69349 flv cleanup / simplify
michaelni
parents: 1353
diff changeset
197 void h263_encode_picture_header(MpegEncContext * s, int picture_number)
1f89adb69349 flv cleanup / simplify
michaelni
parents: 1353
diff changeset
198 {
1f89adb69349 flv cleanup / simplify
michaelni
parents: 1353
diff changeset
199 int format;
1f89adb69349 flv cleanup / simplify
michaelni
parents: 1353
diff changeset
200
1f89adb69349 flv cleanup / simplify
michaelni
parents: 1353
diff changeset
201 align_put_bits(&s->pb);
1353
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
202
231
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
203 /* Update the pointer to last GOB */
234
5fc0c3af3fe4 alternative bitstream writer (disabled by default, uncomment #define ALT_BISTREAM_WRITER in common.h if u want to try it)
michaelni
parents: 231
diff changeset
204 s->ptr_lastgob = pbBufPtr(&s->pb);
231
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
205 put_bits(&s->pb, 22, 0x20); /* PSC */
1126
77ccf7fe3bd0 per context frame_rate_base, this should finally fix frame_rate related av sync issues
michaelni
parents: 1118
diff changeset
206 put_bits(&s->pb, 8, (((int64_t)s->picture_number * 30 * s->avctx->frame_rate_base) /
77ccf7fe3bd0 per context frame_rate_base, this should finally fix frame_rate related av sync issues
michaelni
parents: 1118
diff changeset
207 s->avctx->frame_rate) & 0xff);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
208
986e461dc072 Initial revision
glantau
parents:
diff changeset
209 put_bits(&s->pb, 1, 1); /* marker */
986e461dc072 Initial revision
glantau
parents:
diff changeset
210 put_bits(&s->pb, 1, 0); /* h263 id */
986e461dc072 Initial revision
glantau
parents:
diff changeset
211 put_bits(&s->pb, 1, 0); /* split screen off */
986e461dc072 Initial revision
glantau
parents:
diff changeset
212 put_bits(&s->pb, 1, 0); /* camera off */
986e461dc072 Initial revision
glantau
parents:
diff changeset
213 put_bits(&s->pb, 1, 0); /* freeze picture release off */
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
214
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
215 format = h263_get_picture_format(s->width, s->height);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
216 if (!s->h263_plus) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
217 /* H.263v1 */
986e461dc072 Initial revision
glantau
parents:
diff changeset
218 put_bits(&s->pb, 3, format);
986e461dc072 Initial revision
glantau
parents:
diff changeset
219 put_bits(&s->pb, 1, (s->pict_type == P_TYPE));
986e461dc072 Initial revision
glantau
parents:
diff changeset
220 /* By now UMV IS DISABLED ON H.263v1, since the restrictions
986e461dc072 Initial revision
glantau
parents:
diff changeset
221 of H.263v1 UMV implies to check the predicted MV after
986e461dc072 Initial revision
glantau
parents:
diff changeset
222 calculation of the current MB to see if we're on the limits */
986e461dc072 Initial revision
glantau
parents:
diff changeset
223 put_bits(&s->pb, 1, 0); /* unrestricted motion vector: off */
986e461dc072 Initial revision
glantau
parents:
diff changeset
224 put_bits(&s->pb, 1, 0); /* SAC: off */
1633
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
225 put_bits(&s->pb, 1, s->obmc); /* advanced prediction mode */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
226 put_bits(&s->pb, 1, 0); /* not PB frame */
986e461dc072 Initial revision
glantau
parents:
diff changeset
227 put_bits(&s->pb, 5, s->qscale);
986e461dc072 Initial revision
glantau
parents:
diff changeset
228 put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */
986e461dc072 Initial revision
glantau
parents:
diff changeset
229 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
230 /* H.263v2 */
986e461dc072 Initial revision
glantau
parents:
diff changeset
231 /* H.263 Plus PTYPE */
986e461dc072 Initial revision
glantau
parents:
diff changeset
232 put_bits(&s->pb, 3, 7);
986e461dc072 Initial revision
glantau
parents:
diff changeset
233 put_bits(&s->pb,3,1); /* Update Full Extended PTYPE */
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
234 if (format == 7)
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
235 put_bits(&s->pb,3,6); /* Custom Source Format */
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
236 else
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
237 put_bits(&s->pb, 3, format);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
238
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
239 put_bits(&s->pb,1,0); /* Custom PCF: off */
1661
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
240 put_bits(&s->pb,1, s->umvplus); /* Unrestricted Motion Vector */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
241 put_bits(&s->pb,1,0); /* SAC: off */
1633
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
242 put_bits(&s->pb,1,s->obmc); /* Advanced Prediction Mode */
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
243 put_bits(&s->pb,1,s->h263_aic); /* Advanced Intra Coding */
1644
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
244 put_bits(&s->pb,1,s->loop_filter); /* Deblocking Filter */
1661
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
245 put_bits(&s->pb,1,s->h263_slice_structured); /* Slice Structured */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
246 put_bits(&s->pb,1,0); /* Reference Picture Selection: off */
986e461dc072 Initial revision
glantau
parents:
diff changeset
247 put_bits(&s->pb,1,0); /* Independent Segment Decoding: off */
1637
7799582dc9b8 h263 alternative inter vlc support
michael
parents: 1633
diff changeset
248 put_bits(&s->pb,1,s->alt_inter_vlc); /* Alternative Inter VLC */
1644
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
249 put_bits(&s->pb,1,s->modified_quant); /* Modified Quantization: */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
250 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
986e461dc072 Initial revision
glantau
parents:
diff changeset
251 put_bits(&s->pb,3,0); /* Reserved */
986e461dc072 Initial revision
glantau
parents:
diff changeset
252
986e461dc072 Initial revision
glantau
parents:
diff changeset
253 put_bits(&s->pb, 3, s->pict_type == P_TYPE);
986e461dc072 Initial revision
glantau
parents:
diff changeset
254
986e461dc072 Initial revision
glantau
parents:
diff changeset
255 put_bits(&s->pb,1,0); /* Reference Picture Resampling: off */
986e461dc072 Initial revision
glantau
parents:
diff changeset
256 put_bits(&s->pb,1,0); /* Reduced-Resolution Update: off */
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
257 put_bits(&s->pb,1,s->no_rounding); /* Rounding Type */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
258 put_bits(&s->pb,2,0); /* Reserved */
986e461dc072 Initial revision
glantau
parents:
diff changeset
259 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
986e461dc072 Initial revision
glantau
parents:
diff changeset
260
986e461dc072 Initial revision
glantau
parents:
diff changeset
261 /* This should be here if PLUSPTYPE */
986e461dc072 Initial revision
glantau
parents:
diff changeset
262 put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */
986e461dc072 Initial revision
glantau
parents:
diff changeset
263
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
264 if (format == 7) {
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
265 /* Custom Picture Format (CPFMT) */
1548
dd544554ed42 AVRational
michael
parents: 1542
diff changeset
266 aspect_to_info(s, s->avctx->sample_aspect_ratio);
880
1c32039e7215 aspect ratio cleanup
michaelni
parents: 853
diff changeset
267
1c32039e7215 aspect ratio cleanup
michaelni
parents: 853
diff changeset
268 put_bits(&s->pb,4,s->aspect_ratio_info);
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
269 put_bits(&s->pb,9,(s->width >> 2) - 1);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
270 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
271 put_bits(&s->pb,9,(s->height >> 2));
1548
dd544554ed42 AVRational
michael
parents: 1542
diff changeset
272 if (s->aspect_ratio_info == FF_ASPECT_EXTENDED){
dd544554ed42 AVRational
michael
parents: 1542
diff changeset
273 put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.num);
dd544554ed42 AVRational
michael
parents: 1542
diff changeset
274 put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.den);
669
b4bddbde44f3 aspect (ext. par too) support for h263 and mpeg4 (inc. build becouse of new vars)
al3x
parents: 667
diff changeset
275 }
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
276 }
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
277
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
278 /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
79
82e579c37bc3 Moved some H.263+ variables to MpegEncContext to be thread-safe.
pulento
parents: 78
diff changeset
279 if (s->umvplus)
1089
7e79a58954b1 h263(+) clenaup & bugfixes
michaelni
parents: 1070
diff changeset
280 // put_bits(&s->pb,1,1); /* Limited according tables of Annex D */
1644
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
281 //FIXME check actual requested range
1089
7e79a58954b1 h263(+) clenaup & bugfixes
michaelni
parents: 1070
diff changeset
282 put_bits(&s->pb,2,1); /* unlimited */
1661
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
283 if(s->h263_slice_structured)
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
284 put_bits(&s->pb,2,0); /* no weird submodes */
1089
7e79a58954b1 h263(+) clenaup & bugfixes
michaelni
parents: 1070
diff changeset
285
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
286 put_bits(&s->pb, 5, s->qscale);
986e461dc072 Initial revision
glantau
parents:
diff changeset
287 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
288
986e461dc072 Initial revision
glantau
parents:
diff changeset
289 put_bits(&s->pb, 1, 0); /* no PEI */
498
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
290
1670
d6f2520c0c43 slice structured fixes
michael
parents: 1668
diff changeset
291 if(s->h263_slice_structured){
d6f2520c0c43 slice structured fixes
michael
parents: 1668
diff changeset
292 put_bits(&s->pb, 1, 1);
d6f2520c0c43 slice structured fixes
michael
parents: 1668
diff changeset
293
d6f2520c0c43 slice structured fixes
michael
parents: 1668
diff changeset
294 assert(s->mb_x == 0 && s->mb_y == 0);
d6f2520c0c43 slice structured fixes
michael
parents: 1668
diff changeset
295 ff_h263_encode_mba(s);
d6f2520c0c43 slice structured fixes
michael
parents: 1668
diff changeset
296
d6f2520c0c43 slice structured fixes
michael
parents: 1668
diff changeset
297 put_bits(&s->pb, 1, 1);
d6f2520c0c43 slice structured fixes
michael
parents: 1668
diff changeset
298 }
d6f2520c0c43 slice structured fixes
michael
parents: 1668
diff changeset
299
498
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
300 if(s->h263_aic){
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
301 s->y_dc_scale_table=
1639
3e2b774edce4 rv20 decoder
michael
parents: 1637
diff changeset
302 s->c_dc_scale_table= ff_aic_dc_scale_table;
498
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
303 }else{
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
304 s->y_dc_scale_table=
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
305 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
306 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
307 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
308
766
8d36b35a7e6e slice encoding cleanup
michaelni
parents: 761
diff changeset
309 /**
8d36b35a7e6e slice encoding cleanup
michaelni
parents: 761
diff changeset
310 * Encodes a group of blocks header.
8d36b35a7e6e slice encoding cleanup
michaelni
parents: 761
diff changeset
311 */
1661
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
312 void h263_encode_gob_header(MpegEncContext * s, int mb_line)
162
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
313 {
1661
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
314 put_bits(&s->pb, 17, 1); /* GBSC */
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
315
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
316 if(s->h263_slice_structured){
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
317 put_bits(&s->pb, 1, 1);
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
318
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
319 ff_h263_encode_mba(s);
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
320
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
321 if(s->mb_num > 1583)
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
322 put_bits(&s->pb, 1, 1);
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
323 put_bits(&s->pb, 5, s->qscale); /* GQUANT */
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
324 put_bits(&s->pb, 1, 1);
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
325 put_bits(&s->pb, 2, s->pict_type == I_TYPE); /* GFID */
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
326 }else{
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
327 int gob_number= mb_line / s->gob_index;
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
328
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
329 put_bits(&s->pb, 5, gob_number); /* GN */
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
330 put_bits(&s->pb, 2, s->pict_type == I_TYPE); /* GFID */
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
331 put_bits(&s->pb, 5, s->qscale); /* GQUANT */
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
332 }
162
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
333 }
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
334
1492
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
335 static inline int get_block_rate(MpegEncContext * s, DCTELEM block[64], int block_last_index, uint8_t scantable[64]){
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
336 int last=0;
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
337 int j;
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
338 int rate=0;
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
339
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
340 for(j=1; j<=block_last_index; j++){
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
341 const int index= scantable[j];
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
342 int level= block[index];
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
343 if(level){
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
344 level+= 64;
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
345 if((level&(~127)) == 0){
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
346 if(j<block_last_index) rate+= s->intra_ac_vlc_length [UNI_AC_ENC_INDEX(j-last-1, level)];
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
347 else rate+= s->intra_ac_vlc_last_length[UNI_AC_ENC_INDEX(j-last-1, level)];
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
348 }else
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
349 rate += s->ac_esc_length;
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
350 level-= 64;
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
351
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
352 last= j;
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
353 }
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
354 }
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
355
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
356 return rate;
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
357 }
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
358
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
359 static inline int decide_ac_pred(MpegEncContext * s, DCTELEM block[6][64], int dir[6], uint8_t *st[6], int zigzag_last_index[6])
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
360 {
1492
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
361 int score= 0;
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
362 int i, n;
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
363 int8_t * const qscale_table= s->current_picture.qscale_table;
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
364
1492
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
365 memcpy(zigzag_last_index, s->block_last_index, sizeof(int)*6);
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
366
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
367 for(n=0; n<6; n++){
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
368 int16_t *ac_val, *ac_val1;
1492
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
369
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
370 score -= get_block_rate(s, block[n], s->block_last_index[n], s->intra_scantable.permutated);
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
371
266
252444e5259b optimization
michaelni
parents: 265
diff changeset
372 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
373 ac_val1= ac_val;
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
374 if(dir[n]){
1177
fea03d2c4946 simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents: 1176
diff changeset
375 const int xy= s->mb_x + s->mb_y*s->mb_stride - s->mb_stride;
692
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
376 /* top prediction */
266
252444e5259b optimization
michaelni
parents: 265
diff changeset
377 ac_val-= s->block_wrap[n]*16;
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
378 if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){
692
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
379 /* same qscale */
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
380 for(i=1; i<8; i++){
1092
f59c3f66363b MpegEncContext.(i)dct_* -> DspContext.(i)dct_*
michaelni
parents: 1090
diff changeset
381 const int level= block[n][s->dsp.idct_permutation[i ]];
1492
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
382 block[n][s->dsp.idct_permutation[i ]] = level - ac_val[i+8];
1092
f59c3f66363b MpegEncContext.(i)dct_* -> DspContext.(i)dct_*
michaelni
parents: 1090
diff changeset
383 ac_val1[i ]= block[n][s->dsp.idct_permutation[i<<3]];
692
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
384 ac_val1[i+8]= level;
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
385 }
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
386 }else{
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
387 /* different qscale, we must rescale */
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
388 for(i=1; i<8; i++){
1092
f59c3f66363b MpegEncContext.(i)dct_* -> DspContext.(i)dct_*
michaelni
parents: 1090
diff changeset
389 const int level= block[n][s->dsp.idct_permutation[i ]];
1492
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
390 block[n][s->dsp.idct_permutation[i ]] = level - ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale);
1092
f59c3f66363b MpegEncContext.(i)dct_* -> DspContext.(i)dct_*
michaelni
parents: 1090
diff changeset
391 ac_val1[i ]= block[n][s->dsp.idct_permutation[i<<3]];
692
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
392 ac_val1[i+8]= level;
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
393 }
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
394 }
1492
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
395 st[n]= s->intra_h_scantable.permutated;
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
396 }else{
1177
fea03d2c4946 simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents: 1176
diff changeset
397 const int xy= s->mb_x-1 + s->mb_y*s->mb_stride;
692
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
398 /* left prediction */
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
399 ac_val-= 16;
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
400 if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){
692
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
401 /* same qscale */
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
402 for(i=1; i<8; i++){
1092
f59c3f66363b MpegEncContext.(i)dct_* -> DspContext.(i)dct_*
michaelni
parents: 1090
diff changeset
403 const int level= block[n][s->dsp.idct_permutation[i<<3]];
1492
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
404 block[n][s->dsp.idct_permutation[i<<3]]= level - ac_val[i];
692
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
405 ac_val1[i ]= level;
1092
f59c3f66363b MpegEncContext.(i)dct_* -> DspContext.(i)dct_*
michaelni
parents: 1090
diff changeset
406 ac_val1[i+8]= block[n][s->dsp.idct_permutation[i ]];
692
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
407 }
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
408 }else{
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
409 /* different qscale, we must rescale */
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
410 for(i=1; i<8; i++){
1092
f59c3f66363b MpegEncContext.(i)dct_* -> DspContext.(i)dct_*
michaelni
parents: 1090
diff changeset
411 const int level= block[n][s->dsp.idct_permutation[i<<3]];
1492
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
412 block[n][s->dsp.idct_permutation[i<<3]]= level - ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale);
692
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
413 ac_val1[i ]= level;
1092
f59c3f66363b MpegEncContext.(i)dct_* -> DspContext.(i)dct_*
michaelni
parents: 1090
diff changeset
414 ac_val1[i+8]= block[n][s->dsp.idct_permutation[i ]];
692
852b5a416161 fixing ac prediction encoding with adaptive quantization
michaelni
parents: 690
diff changeset
415 }
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
416 }
1492
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
417 st[n]= s->intra_v_scantable.permutated;
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
418 }
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
419
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
420 for(i=63; i>0; i--) //FIXME optimize
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
421 if(block[n][ st[n][i] ]) break;
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
422 s->block_last_index[n]= i;
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
423
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
424 score += get_block_rate(s, block[n], s->block_last_index[n], st[n]);
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
425 }
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
426
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
427 return score < 0;
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
428 }
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
429
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
430 static inline void restore_ac_coeffs(MpegEncContext * s, DCTELEM block[6][64], int dir[6], uint8_t *st[6], int zigzag_last_index[6])
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
431 {
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
432 int i, n;
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
433 memcpy(s->block_last_index, zigzag_last_index, sizeof(int)*6);
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
434
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
435 for(n=0; n<6; n++){
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
436 int16_t *ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
437
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
438 st[n]= s->intra_scantable.permutated;
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
439 if(dir[n]){
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
440 /* top prediction */
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
441 for(i=1; i<8; i++){
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
442 block[n][s->dsp.idct_permutation[i ]] = ac_val[i+8];
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
443 }
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
444 }else{
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
445 /* left prediction */
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
446 for(i=1; i<8; i++){
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
447 block[n][s->dsp.idct_permutation[i<<3]]= ac_val[i ];
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
448 }
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
449 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
450 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
451 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
452
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
453 /**
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
454 * modify qscale so that encoding is acually possible in h263 (limit difference to -2..2)
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
455 */
695
3525da287ee2 adaptive quantization for h263
michaelni
parents: 692
diff changeset
456 void ff_clean_h263_qscales(MpegEncContext *s){
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
457 int i;
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
458 int8_t * const qscale_table= s->current_picture.qscale_table;
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
459
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
460 for(i=1; i<s->mb_num; i++){
1177
fea03d2c4946 simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents: 1176
diff changeset
461 if(qscale_table[ s->mb_index2xy[i] ] - qscale_table[ s->mb_index2xy[i-1] ] >2)
fea03d2c4946 simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents: 1176
diff changeset
462 qscale_table[ s->mb_index2xy[i] ]= qscale_table[ s->mb_index2xy[i-1] ]+2;
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
463 }
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
464 for(i=s->mb_num-2; i>=0; i--){
1177
fea03d2c4946 simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents: 1176
diff changeset
465 if(qscale_table[ s->mb_index2xy[i] ] - qscale_table[ s->mb_index2xy[i+1] ] >2)
fea03d2c4946 simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents: 1176
diff changeset
466 qscale_table[ s->mb_index2xy[i] ]= qscale_table[ s->mb_index2xy[i+1] ]+2;
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
467 }
695
3525da287ee2 adaptive quantization for h263
michaelni
parents: 692
diff changeset
468 }
3525da287ee2 adaptive quantization for h263
michaelni
parents: 692
diff changeset
469
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
470 /**
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
471 * modify mb_type & qscale so that encoding is acually possible in mpeg4
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
472 */
695
3525da287ee2 adaptive quantization for h263
michaelni
parents: 692
diff changeset
473 void ff_clean_mpeg4_qscales(MpegEncContext *s){
3525da287ee2 adaptive quantization for h263
michaelni
parents: 692
diff changeset
474 int i;
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
475 int8_t * const qscale_table= s->current_picture.qscale_table;
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
476
695
3525da287ee2 adaptive quantization for h263
michaelni
parents: 692
diff changeset
477 ff_clean_h263_qscales(s);
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
478
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
479 for(i=1; i<s->mb_num; i++){
1177
fea03d2c4946 simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents: 1176
diff changeset
480 int mb_xy= s->mb_index2xy[i];
fea03d2c4946 simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents: 1176
diff changeset
481
1708
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
482 if(qscale_table[mb_xy] != qscale_table[s->mb_index2xy[i-1]] && (s->mb_type[mb_xy]&CANDIDATE_MB_TYPE_INTER4V)){
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
483 s->mb_type[mb_xy]&= ~CANDIDATE_MB_TYPE_INTER4V;
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
484 s->mb_type[mb_xy]|= CANDIDATE_MB_TYPE_INTER;
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
485 }
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
486 }
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
487
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
488 if(s->pict_type== B_TYPE){
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
489 int odd=0;
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
490 /* ok, come on, this isnt funny anymore, theres more code for handling this mpeg4 mess than
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
491 for the actual adaptive quantization */
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
492
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
493 for(i=0; i<s->mb_num; i++){
1177
fea03d2c4946 simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents: 1176
diff changeset
494 int mb_xy= s->mb_index2xy[i];
fea03d2c4946 simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents: 1176
diff changeset
495 odd += qscale_table[mb_xy]&1;
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
496 }
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
497
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
498 if(2*odd > s->mb_num) odd=1;
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
499 else odd=0;
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
500
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
501 for(i=0; i<s->mb_num; i++){
1177
fea03d2c4946 simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents: 1176
diff changeset
502 int mb_xy= s->mb_index2xy[i];
fea03d2c4946 simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents: 1176
diff changeset
503 if((qscale_table[mb_xy]&1) != odd)
fea03d2c4946 simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents: 1176
diff changeset
504 qscale_table[mb_xy]++;
fea03d2c4946 simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents: 1176
diff changeset
505 if(qscale_table[mb_xy] > 31)
fea03d2c4946 simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents: 1176
diff changeset
506 qscale_table[mb_xy]= 31;
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
507 }
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
508
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
509 for(i=1; i<s->mb_num; i++){
1177
fea03d2c4946 simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents: 1176
diff changeset
510 int mb_xy= s->mb_index2xy[i];
1708
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
511 if(qscale_table[mb_xy] != qscale_table[s->mb_index2xy[i-1]] && (s->mb_type[mb_xy]&CANDIDATE_MB_TYPE_DIRECT)){
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
512 s->mb_type[mb_xy]&= ~CANDIDATE_MB_TYPE_DIRECT;
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
513 s->mb_type[mb_xy]|= CANDIDATE_MB_TYPE_BIDIR;
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
514 }
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
515 }
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
516 }
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
517 }
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
518
1070
6da5ae9ee199 more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents: 1068
diff changeset
519 #endif //CONFIG_ENCODERS
1177
fea03d2c4946 simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents: 1176
diff changeset
520 /**
fea03d2c4946 simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents: 1176
diff changeset
521 *
fea03d2c4946 simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents: 1176
diff changeset
522 * @return the mb_type
fea03d2c4946 simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents: 1176
diff changeset
523 */
fea03d2c4946 simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents: 1176
diff changeset
524 int ff_mpeg4_set_direct_mv(MpegEncContext *s, int mx, int my){
fea03d2c4946 simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents: 1176
diff changeset
525 const int mb_index= s->mb_x + s->mb_y*s->mb_stride;
1708
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
526 const int colocated_mb_type= s->next_picture.mb_type[mb_index];
936
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
527 int xy= s->block_index[0];
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
528 uint16_t time_pp= s->pp_time;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
529 uint16_t time_pb= s->pb_time;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
530 int i;
1053
f07fd48c23d4 direct blocksize in bframes fix (might fix qpel+bframe bug)
michaelni
parents: 1042
diff changeset
531
936
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
532 //FIXME avoid divides
1177
fea03d2c4946 simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents: 1176
diff changeset
533
fea03d2c4946 simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents: 1176
diff changeset
534 if(IS_8X8(colocated_mb_type)){
936
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
535 s->mv_type = MV_TYPE_8X8;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
536 for(i=0; i<4; i++){
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
537 xy= s->block_index[i];
1668
30746f429df6 move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents: 1666
diff changeset
538 s->mv[0][i][0] = s->next_picture.motion_val[0][xy][0]*time_pb/time_pp + mx;
30746f429df6 move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents: 1666
diff changeset
539 s->mv[0][i][1] = s->next_picture.motion_val[0][xy][1]*time_pb/time_pp + my;
30746f429df6 move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents: 1666
diff changeset
540 s->mv[1][i][0] = mx ? s->mv[0][i][0] - s->next_picture.motion_val[0][xy][0]
30746f429df6 move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents: 1666
diff changeset
541 : s->next_picture.motion_val[0][xy][0]*(time_pb - time_pp)/time_pp;
30746f429df6 move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents: 1666
diff changeset
542 s->mv[1][i][1] = my ? s->mv[0][i][1] - s->next_picture.motion_val[0][xy][1]
30746f429df6 move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents: 1666
diff changeset
543 : s->next_picture.motion_val[0][xy][1]*(time_pb - time_pp)/time_pp;
936
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
544 }
1177
fea03d2c4946 simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents: 1176
diff changeset
545 return MB_TYPE_DIRECT2 | MB_TYPE_8x8 | MB_TYPE_L0L1;
fea03d2c4946 simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents: 1176
diff changeset
546 } else if(IS_INTERLACED(colocated_mb_type)){
936
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
547 s->mv_type = MV_TYPE_FIELD;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
548 for(i=0; i<2; i++){
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
549 if(s->top_field_first){
1708
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
550 time_pp= s->pp_field_time - s->p_field_select_table[i][mb_index] + i;
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
551 time_pb= s->pb_field_time - s->p_field_select_table[i][mb_index] + i;
936
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
552 }else{
1708
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
553 time_pp= s->pp_field_time + s->p_field_select_table[i][mb_index] - i;
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
554 time_pb= s->pb_field_time + s->p_field_select_table[i][mb_index] - i;
936
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
555 }
1708
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
556 s->mv[0][i][0] = s->p_field_mv_table[i][0][mb_index][0]*time_pb/time_pp + mx;
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
557 s->mv[0][i][1] = s->p_field_mv_table[i][0][mb_index][1]*time_pb/time_pp + my;
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
558 s->mv[1][i][0] = mx ? s->mv[0][i][0] - s->p_field_mv_table[i][0][mb_index][0]
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
559 : s->p_field_mv_table[i][0][mb_index][0]*(time_pb - time_pp)/time_pp;
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
560 s->mv[1][i][1] = my ? s->mv[0][i][1] - s->p_field_mv_table[i][0][mb_index][1]
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
561 : s->p_field_mv_table[i][0][mb_index][1]*(time_pb - time_pp)/time_pp;
936
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
562 }
1177
fea03d2c4946 simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents: 1176
diff changeset
563 return MB_TYPE_DIRECT2 | MB_TYPE_16x8 | MB_TYPE_L0L1 | MB_TYPE_INTERLACED;
fea03d2c4946 simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents: 1176
diff changeset
564 }else{
1668
30746f429df6 move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents: 1666
diff changeset
565 s->mv[0][0][0] = s->mv[0][1][0] = s->mv[0][2][0] = s->mv[0][3][0] = s->next_picture.motion_val[0][xy][0]*time_pb/time_pp + mx;
30746f429df6 move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents: 1666
diff changeset
566 s->mv[0][0][1] = s->mv[0][1][1] = s->mv[0][2][1] = s->mv[0][3][1] = s->next_picture.motion_val[0][xy][1]*time_pb/time_pp + my;
30746f429df6 move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents: 1666
diff changeset
567 s->mv[1][0][0] = s->mv[1][1][0] = s->mv[1][2][0] = s->mv[1][3][0] = mx ? s->mv[0][0][0] - s->next_picture.motion_val[0][xy][0]
30746f429df6 move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents: 1666
diff changeset
568 : s->next_picture.motion_val[0][xy][0]*(time_pb - time_pp)/time_pp;
30746f429df6 move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents: 1666
diff changeset
569 s->mv[1][0][1] = s->mv[1][1][1] = s->mv[1][2][1] = s->mv[1][3][1] = my ? s->mv[0][0][1] - s->next_picture.motion_val[0][xy][1]
30746f429df6 move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents: 1666
diff changeset
570 : s->next_picture.motion_val[0][xy][1]*(time_pb - time_pp)/time_pp;
1177
fea03d2c4946 simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents: 1176
diff changeset
571 if((s->avctx->workaround_bugs & FF_BUG_DIRECT_BLOCKSIZE) || !s->quarter_sample)
fea03d2c4946 simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents: 1176
diff changeset
572 s->mv_type= MV_TYPE_16X16;
fea03d2c4946 simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents: 1176
diff changeset
573 else
fea03d2c4946 simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents: 1176
diff changeset
574 s->mv_type= MV_TYPE_8X8;
fea03d2c4946 simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents: 1176
diff changeset
575 return MB_TYPE_DIRECT2 | MB_TYPE_16x16 | MB_TYPE_L0L1; //Note see prev line
936
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
576 }
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
577 }
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
578
1389
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1366
diff changeset
579 void ff_h263_update_motion_val(MpegEncContext * s){
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1366
diff changeset
580 const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1366
diff changeset
581 //FIXME a lot of thet is only needed for !low_delay
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1366
diff changeset
582 const int wrap = s->block_wrap[0];
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1366
diff changeset
583 const int xy = s->block_index[0];
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1366
diff changeset
584
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1366
diff changeset
585 s->current_picture.mbskip_table[mb_xy]= s->mb_skiped;
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1366
diff changeset
586
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1366
diff changeset
587 if(s->mv_type != MV_TYPE_8X8){
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1366
diff changeset
588 int motion_x, motion_y;
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1366
diff changeset
589 if (s->mb_intra) {
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1366
diff changeset
590 motion_x = 0;
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1366
diff changeset
591 motion_y = 0;
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1366
diff changeset
592 } else if (s->mv_type == MV_TYPE_16X16) {
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1366
diff changeset
593 motion_x = s->mv[0][0][0];
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1366
diff changeset
594 motion_y = s->mv[0][0][1];
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1366
diff changeset
595 } else /*if (s->mv_type == MV_TYPE_FIELD)*/ {
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1366
diff changeset
596 int i;
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1366
diff changeset
597 motion_x = s->mv[0][0][0] + s->mv[0][1][0];
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1366
diff changeset
598 motion_y = s->mv[0][0][1] + s->mv[0][1][1];
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1366
diff changeset
599 motion_x = (motion_x>>1) | (motion_x&1);
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1366
diff changeset
600 for(i=0; i<2; i++){
1708
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
601 s->p_field_mv_table[i][0][mb_xy][0]= s->mv[0][i][0];
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
602 s->p_field_mv_table[i][0][mb_xy][1]= s->mv[0][i][1];
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
603 s->p_field_select_table[i][mb_xy]= s->field_select[0][i];
1389
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1366
diff changeset
604 }
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1366
diff changeset
605 }
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1366
diff changeset
606
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1366
diff changeset
607 /* no update if 8X8 because it has been done during parsing */
1668
30746f429df6 move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents: 1666
diff changeset
608 s->current_picture.motion_val[0][xy][0] = motion_x;
30746f429df6 move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents: 1666
diff changeset
609 s->current_picture.motion_val[0][xy][1] = motion_y;
30746f429df6 move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents: 1666
diff changeset
610 s->current_picture.motion_val[0][xy + 1][0] = motion_x;
30746f429df6 move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents: 1666
diff changeset
611 s->current_picture.motion_val[0][xy + 1][1] = motion_y;
30746f429df6 move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents: 1666
diff changeset
612 s->current_picture.motion_val[0][xy + wrap][0] = motion_x;
30746f429df6 move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents: 1666
diff changeset
613 s->current_picture.motion_val[0][xy + wrap][1] = motion_y;
30746f429df6 move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents: 1666
diff changeset
614 s->current_picture.motion_val[0][xy + 1 + wrap][0] = motion_x;
30746f429df6 move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents: 1666
diff changeset
615 s->current_picture.motion_val[0][xy + 1 + wrap][1] = motion_y;
1389
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1366
diff changeset
616 }
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1366
diff changeset
617
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1366
diff changeset
618 if(s->encoding){ //FIXME encoding MUST be cleaned up
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1366
diff changeset
619 if (s->mv_type == MV_TYPE_8X8)
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1366
diff changeset
620 s->current_picture.mb_type[mb_xy]= MB_TYPE_L0 | MB_TYPE_8x8;
1633
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
621 else if(s->mb_intra)
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
622 s->current_picture.mb_type[mb_xy]= MB_TYPE_INTRA;
1389
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1366
diff changeset
623 else
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1366
diff changeset
624 s->current_picture.mb_type[mb_xy]= MB_TYPE_L0 | MB_TYPE_16x16;
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1366
diff changeset
625 }
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1366
diff changeset
626 }
da0b3a50d209 rate distortion mb decision support
michaelni
parents: 1366
diff changeset
627
815
78accc54493b put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents: 770
diff changeset
628 #ifdef CONFIG_ENCODERS
1490
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
629
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
630 static inline int get_p_cbp(MpegEncContext * s,
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
631 DCTELEM block[6][64],
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
632 int motion_x, int motion_y){
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
633 int cbp, i;
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
634
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
635 if(s->flags & CODEC_FLAG_CBP_RD){
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
636 int best_cbpy_score= INT_MAX;
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
637 int best_cbpc_score= INT_MAX;
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1586
diff changeset
638 int cbpc = (-1), cbpy= (-1);
1490
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
639 const int offset= (s->mv_type==MV_TYPE_16X16 ? 0 : 16) + (s->dquant ? 8 : 0);
1505
010f76d07a27 use lagrange multipler instead of qp for ratecontrol, this may break some things, tell me ASAP if u notice anything broken
michaelni
parents: 1492
diff changeset
640 const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
1490
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
641
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
642 for(i=0; i<4; i++){
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
643 int score= inter_MCBPC_bits[i + offset] * lambda;
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
644 if(i&1) score += s->coded_score[5];
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
645 if(i&2) score += s->coded_score[4];
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
646
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
647 if(score < best_cbpc_score){
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
648 best_cbpc_score= score;
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
649 cbpc= i;
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
650 }
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
651 }
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
652
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
653 for(i=0; i<16; i++){
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
654 int score= cbpy_tab[i ^ 0xF][1] * lambda;
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
655 if(i&1) score += s->coded_score[3];
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
656 if(i&2) score += s->coded_score[2];
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
657 if(i&4) score += s->coded_score[1];
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
658 if(i&8) score += s->coded_score[0];
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
659
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
660 if(score < best_cbpy_score){
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
661 best_cbpy_score= score;
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
662 cbpy= i;
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
663 }
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
664 }
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
665 cbp= cbpc + 4*cbpy;
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
666 if ((motion_x | motion_y | s->dquant) == 0 && s->mv_type==MV_TYPE_16X16){
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
667 if(best_cbpy_score + best_cbpc_score + 2*lambda >= 0)
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
668 cbp= 0;
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
669 }
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
670
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
671 for (i = 0; i < 6; i++) {
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
672 if (s->block_last_index[i] >= 0 && ((cbp >> (5 - i))&1)==0 ){
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
673 s->block_last_index[i]= -1;
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
674 memset(s->block[i], 0, sizeof(DCTELEM)*64);
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
675 }
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
676 }
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
677 }else{
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
678 cbp= 0;
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
679 for (i = 0; i < 6; i++) {
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
680 if (s->block_last_index[i] >= 0)
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
681 cbp |= 1 << (5 - i);
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
682 }
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
683 }
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
684 return cbp;
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
685 }
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
686
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
687 static inline int get_b_cbp(MpegEncContext * s, DCTELEM block[6][64],
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
688 int motion_x, int motion_y, int mb_type){
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
689 int cbp=0, i;
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
690
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
691 if(s->flags & CODEC_FLAG_CBP_RD){
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
692 int score=0;
1505
010f76d07a27 use lagrange multipler instead of qp for ratecontrol, this may break some things, tell me ASAP if u notice anything broken
michaelni
parents: 1492
diff changeset
693 const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
1490
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
694
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
695 for(i=0; i<6; i++){
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
696 if(s->coded_score[i] < 0){
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
697 score += s->coded_score[i];
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
698 cbp |= 1 << (5 - i);
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
699 }
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
700 }
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
701
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
702 if(cbp){
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
703 int zero_score= -6;
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
704 if ((motion_x | motion_y | s->dquant | mb_type) == 0){
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
705 zero_score-= 4; //2*MV + mb_type + cbp bit
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
706 }
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
707
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
708 zero_score*= lambda;
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
709 if(zero_score <= score){
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
710 cbp=0;
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
711 }
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
712 }
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
713
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
714 for (i = 0; i < 6; i++) {
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
715 if (s->block_last_index[i] >= 0 && ((cbp >> (5 - i))&1)==0 ){
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
716 s->block_last_index[i]= -1;
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
717 memset(s->block[i], 0, sizeof(DCTELEM)*64);
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
718 }
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
719 }
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
720 }else{
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
721 for (i = 0; i < 6; i++) {
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
722 if (s->block_last_index[i] >= 0)
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
723 cbp |= 1 << (5 - i);
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
724 }
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
725 }
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
726 return cbp;
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
727 }
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
728
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
729 void mpeg4_encode_mb(MpegEncContext * s,
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
730 DCTELEM block[6][64],
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
731 int motion_x, int motion_y)
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
732 {
1057
bb5de8a59da8 * static,const,compiler warning cleanup
kabi
parents: 1053
diff changeset
733 int cbpc, cbpy, pred_x, pred_y;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
734 PutBitContext * const pb2 = s->data_partitioning ? &s->pb2 : &s->pb;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
735 PutBitContext * const tex_pb = s->data_partitioning && s->pict_type!=B_TYPE ? &s->tex_pb : &s->pb;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
736 PutBitContext * const dc_pb = s->data_partitioning && s->pict_type!=I_TYPE ? &s->pb2 : &s->pb;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
737 const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1) && !s->data_partitioning ? 1 : 0;
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
738 const int dquant_code[5]= {1,0,9,2,3};
162
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
739
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
740 // printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
741 if (!s->mb_intra) {
1490
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
742 int i, cbp;
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
743
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
744 if(s->pict_type==B_TYPE){
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
745 static const int mb_type_table[8]= {-1, 2, 3, 1,-1,-1,-1, 0}; /* convert from mv_dir to type */
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
746 int mb_type= mb_type_table[s->mv_dir];
1708
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
747
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
748 if(s->mb_x==0){
1708
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
749 for(i=0; i<2; i++){
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
750 s->last_mv[i][0][0]=
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
751 s->last_mv[i][0][1]=
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
752 s->last_mv[i][1][0]=
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
753 s->last_mv[i][1][1]= 0;
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
754 }
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
755 }
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
756
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
757 assert(s->dquant>=-2 && s->dquant<=2);
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
758 assert((s->dquant&1)==0);
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
759 assert(mb_type>=0);
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
760
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
761 /* nothing to do if this MB was skiped in the next P Frame */
1177
fea03d2c4946 simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents: 1176
diff changeset
762 if(s->next_picture.mbskip_table[s->mb_y * s->mb_stride + s->mb_x]){ //FIXME avoid DCT & ...
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
763 s->skip_count++;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
764 s->mv[0][0][0]=
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
765 s->mv[0][0][1]=
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
766 s->mv[1][0][0]=
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
767 s->mv[1][0][1]= 0;
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
768 s->mv_dir= MV_DIR_FORWARD; //doesnt matter
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
769 s->qscale -= s->dquant;
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
770 // s->mb_skiped=1;
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
771
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
772 return;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
773 }
936
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
774
1490
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
775 cbp= get_b_cbp(s, block, motion_x, motion_y, mb_type);
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
776
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
777 if ((cbp | motion_x | motion_y | mb_type) ==0) {
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
778 /* direct MB with MV={0,0} */
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
779 assert(s->dquant==0);
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
780
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
781 put_bits(&s->pb, 1, 1); /* mb not coded modb1=1 */
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
782
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
783 if(interleaved_stats){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
784 s->misc_bits++;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
785 s->last_bits++;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
786 }
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
787 s->skip_count++;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
788 return;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
789 }
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
790
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
791 put_bits(&s->pb, 1, 0); /* mb coded modb1=0 */
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
792 put_bits(&s->pb, 1, cbp ? 0 : 1); /* modb2 */ //FIXME merge
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
793 put_bits(&s->pb, mb_type+1, 1); // this table is so simple that we dont need it :)
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
794 if(cbp) put_bits(&s->pb, 6, cbp);
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
795
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
796 if(cbp && mb_type){
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
797 if(s->dquant)
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
798 put_bits(&s->pb, 2, (s->dquant>>2)+3);
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
799 else
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
800 put_bits(&s->pb, 1, 0);
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
801 }else
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
802 s->qscale -= s->dquant;
697
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
803
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
804 if(!s->progressive_sequence){
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
805 if(cbp)
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
806 put_bits(&s->pb, 1, s->interlaced_dct);
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
807 if(mb_type) // not diect mode
1708
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
808 put_bits(&s->pb, 1, s->mv_type == MV_TYPE_FIELD);
697
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
809 }
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
810
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
811 if(interleaved_stats){
1164
0e3c0c4a7b3d msmpeg4 2pass support & some related cleanup
michaelni
parents: 1162
diff changeset
812 s->misc_bits+= get_bits_diff(s);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
813 }
295
6622b0fd036c mpeg4 4MV encoding
michaelni
parents: 294
diff changeset
814
1708
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
815 if(mb_type == 0){
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
816 assert(s->mv_dir & MV_DIRECT);
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
817 h263_encode_motion(s, motion_x, 1);
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
818 h263_encode_motion(s, motion_y, 1);
656
e47fa3e3f2d5 statistics for forw & back p-MBs instead of just one counter for both
michaelni
parents: 654
diff changeset
819 s->b_count++;
e47fa3e3f2d5 statistics for forw & back p-MBs instead of just one counter for both
michaelni
parents: 654
diff changeset
820 s->f_count++;
1708
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
821 }else{
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
822 assert(mb_type > 0 && mb_type < 4);
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
823 if(s->mv_type != MV_TYPE_FIELD){
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
824 if(s->mv_dir & MV_DIR_FORWARD){
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
825 h263_encode_motion(s, s->mv[0][0][0] - s->last_mv[0][0][0], s->f_code);
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
826 h263_encode_motion(s, s->mv[0][0][1] - s->last_mv[0][0][1], s->f_code);
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
827 s->last_mv[0][0][0]= s->last_mv[0][1][0]= s->mv[0][0][0];
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
828 s->last_mv[0][0][1]= s->last_mv[0][1][1]= s->mv[0][0][1];
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
829 s->f_count++;
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
830 }
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
831 if(s->mv_dir & MV_DIR_BACKWARD){
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
832 h263_encode_motion(s, s->mv[1][0][0] - s->last_mv[1][0][0], s->b_code);
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
833 h263_encode_motion(s, s->mv[1][0][1] - s->last_mv[1][0][1], s->b_code);
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
834 s->last_mv[1][0][0]= s->last_mv[1][1][0]= s->mv[1][0][0];
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
835 s->last_mv[1][0][1]= s->last_mv[1][1][1]= s->mv[1][0][1];
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
836 s->b_count++;
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
837 }
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
838 }else{
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
839 if(s->mv_dir & MV_DIR_FORWARD){
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
840 put_bits(&s->pb, 1, s->field_select[0][0]);
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
841 put_bits(&s->pb, 1, s->field_select[0][1]);
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
842 }
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
843 if(s->mv_dir & MV_DIR_BACKWARD){
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
844 put_bits(&s->pb, 1, s->field_select[1][0]);
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
845 put_bits(&s->pb, 1, s->field_select[1][1]);
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
846 }
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
847 if(s->mv_dir & MV_DIR_FORWARD){
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
848 for(i=0; i<2; i++){
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
849 h263_encode_motion(s, s->mv[0][i][0] - s->last_mv[0][i][0] , s->f_code);
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
850 h263_encode_motion(s, s->mv[0][i][1] - s->last_mv[0][i][1]/2, s->f_code);
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
851 s->last_mv[0][i][0]= s->mv[0][i][0];
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
852 s->last_mv[0][i][1]= s->mv[0][i][1]*2;
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
853 }
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
854 s->f_count++;
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
855 }
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
856 if(s->mv_dir & MV_DIR_BACKWARD){
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
857 for(i=0; i<2; i++){
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
858 h263_encode_motion(s, s->mv[1][i][0] - s->last_mv[1][i][0] , s->b_code);
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
859 h263_encode_motion(s, s->mv[1][i][1] - s->last_mv[1][i][1]/2, s->b_code);
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
860 s->last_mv[1][i][0]= s->mv[1][i][0];
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
861 s->last_mv[1][i][1]= s->mv[1][i][1]*2;
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
862 }
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
863 s->b_count++;
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
864 }
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
865 }
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
866 }
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
867
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
868 if(interleaved_stats){
1164
0e3c0c4a7b3d msmpeg4 2pass support & some related cleanup
michaelni
parents: 1162
diff changeset
869 s->mv_bits+= get_bits_diff(s);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
870 }
295
6622b0fd036c mpeg4 4MV encoding
michaelni
parents: 294
diff changeset
871
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
872 /* encode each block */
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
873 for (i = 0; i < 6; i++) {
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
874 mpeg4_encode_block(s, block[i], i, 0, s->intra_scantable.permutated, NULL, &s->pb);
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
875 }
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
876
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
877 if(interleaved_stats){
1164
0e3c0c4a7b3d msmpeg4 2pass support & some related cleanup
michaelni
parents: 1162
diff changeset
878 s->p_tex_bits+= get_bits_diff(s);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
879 }
1708
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
880
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
881 }else{ /* s->pict_type==B_TYPE */
1490
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
882 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
883
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
884 if ((cbp | motion_x | motion_y | s->dquant) == 0 && s->mv_type==MV_TYPE_16X16) {
331
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
885 /* check if the B frames can skip it too, as we must skip it if we skip here
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
886 why didnt they just compress the skip-mb bits instead of reusing them ?! */
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
887 if(s->max_b_frames>0){
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
888 int i;
364
6b6332e7008a segfault fix for b-frame encoding with height%16!=0
michaelni
parents: 360
diff changeset
889 int x,y, offset;
6b6332e7008a segfault fix for b-frame encoding with height%16!=0
michaelni
parents: 360
diff changeset
890 uint8_t *p_pic;
6b6332e7008a segfault fix for b-frame encoding with height%16!=0
michaelni
parents: 360
diff changeset
891
6b6332e7008a segfault fix for b-frame encoding with height%16!=0
michaelni
parents: 360
diff changeset
892 x= s->mb_x*16;
6b6332e7008a segfault fix for b-frame encoding with height%16!=0
michaelni
parents: 360
diff changeset
893 y= s->mb_y*16;
6b6332e7008a segfault fix for b-frame encoding with height%16!=0
michaelni
parents: 360
diff changeset
894 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
895 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
896
6b6332e7008a segfault fix for b-frame encoding with height%16!=0
michaelni
parents: 360
diff changeset
897 offset= x + y*s->linesize;
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
898 p_pic= s->new_picture.data[0] + offset;
364
6b6332e7008a segfault fix for b-frame encoding with height%16!=0
michaelni
parents: 360
diff changeset
899
331
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
900 s->mb_skiped=1;
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
901 for(i=0; i<s->max_b_frames; i++){
339
b743a6bbab25 segfault fix
michaelni
parents: 336
diff changeset
902 uint8_t *b_pic;
b743a6bbab25 segfault fix
michaelni
parents: 336
diff changeset
903 int diff;
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
904 Picture *pic= s->reordered_input_picture[i+1];
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
905
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
906 if(pic==NULL || pic->pict_type!=B_TYPE) break;
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
907
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
908 b_pic= pic->data[0] + offset + 16; //FIXME +16
1708
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
909 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
910 if(diff>s->qscale*70){ //FIXME check that 70 is optimal
331
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
911 s->mb_skiped=0;
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
912 break;
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
913 }
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
914 }
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
915 }else
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
916 s->mb_skiped=1;
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
917
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
918 if(s->mb_skiped==1){
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
919 /* skip macroblock */
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
920 put_bits(&s->pb, 1, 1);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
921
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
922 if(interleaved_stats){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
923 s->misc_bits++;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
924 s->last_bits++;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
925 }
331
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
926 s->skip_count++;
1271
42ea05e4a391 improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents: 1261
diff changeset
927
331
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
928 return;
853e1eb30468 fix b-frame MB skip
michaelni
parents: 327
diff changeset
929 }
295
6622b0fd036c mpeg4 4MV encoding
michaelni
parents: 294
diff changeset
930 }
364
6b6332e7008a segfault fix for b-frame encoding with height%16!=0
michaelni
parents: 360
diff changeset
931
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
932 put_bits(&s->pb, 1, 0); /* mb coded */
1633
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
933 cbpc = cbp & 3;
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
934 cbpy = cbp >> 2;
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
935 cbpy ^= 0xf;
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
936 if(s->mv_type==MV_TYPE_16X16){
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
937 if(s->dquant) cbpc+= 8;
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
938 put_bits(&s->pb,
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
939 inter_MCBPC_bits[cbpc],
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
940 inter_MCBPC_code[cbpc]);
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
941
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
942 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
943 if(s->dquant)
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
944 put_bits(pb2, 2, dquant_code[s->dquant+2]);
697
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
945
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
946 if(!s->progressive_sequence){
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
947 if(cbp)
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
948 put_bits(pb2, 1, s->interlaced_dct);
1708
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
949 put_bits(pb2, 1, 0);
697
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
950 }
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
951
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
952 if(interleaved_stats){
1164
0e3c0c4a7b3d msmpeg4 2pass support & some related cleanup
michaelni
parents: 1162
diff changeset
953 s->misc_bits+= get_bits_diff(s);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
954 }
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
955
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
956 /* motion vectors: 16x16 mode */
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
957 h263_pred_motion(s, 0, &pred_x, &pred_y);
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
958
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
959 h263_encode_motion(s, motion_x - pred_x, s->f_code);
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
960 h263_encode_motion(s, motion_y - pred_y, s->f_code);
1708
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
961 }else if(s->mv_type==MV_TYPE_FIELD){
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
962 if(s->dquant) cbpc+= 8;
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
963 put_bits(&s->pb,
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
964 inter_MCBPC_bits[cbpc],
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
965 inter_MCBPC_code[cbpc]);
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
966
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
967 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
968 if(s->dquant)
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
969 put_bits(pb2, 2, dquant_code[s->dquant+2]);
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
970
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
971 assert(!s->progressive_sequence);
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
972 if(cbp)
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
973 put_bits(pb2, 1, s->interlaced_dct);
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
974 put_bits(pb2, 1, 1);
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
975
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
976 if(interleaved_stats){
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
977 s->misc_bits+= get_bits_diff(s);
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
978 }
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
979
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
980 /* motion vectors: 16x8 interlaced mode */
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
981 h263_pred_motion(s, 0, &pred_x, &pred_y);
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
982 pred_y /=2;
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
983
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
984 put_bits(&s->pb, 1, s->field_select[0][0]);
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
985 put_bits(&s->pb, 1, s->field_select[0][1]);
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
986
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
987 h263_encode_motion(s, s->mv[0][0][0] - pred_x, s->f_code);
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
988 h263_encode_motion(s, s->mv[0][0][1] - pred_y, s->f_code);
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
989 h263_encode_motion(s, s->mv[0][1][0] - pred_x, s->f_code);
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
990 h263_encode_motion(s, s->mv[0][1][1] - pred_y, s->f_code);
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
991 }else{
1708
dea5b2946999 interlaced motion estimation
michael
parents: 1701
diff changeset
992 assert(s->mv_type==MV_TYPE_8X8);
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
993 put_bits(&s->pb,
1633
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
994 inter_MCBPC_bits[cbpc+16],
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
995 inter_MCBPC_code[cbpc+16]);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
996 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
997
757
d031d1575ceb fixing interlaced dct with 4mv
michaelni
parents: 753
diff changeset
998 if(!s->progressive_sequence){
d031d1575ceb fixing interlaced dct with 4mv
michaelni
parents: 753
diff changeset
999 if(cbp)
d031d1575ceb fixing interlaced dct with 4mv
michaelni
parents: 753
diff changeset
1000 put_bits(pb2, 1, s->interlaced_dct);
d031d1575ceb fixing interlaced dct with 4mv
michaelni
parents: 753
diff changeset
1001 }
d031d1575ceb fixing interlaced dct with 4mv
michaelni
parents: 753
diff changeset
1002
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1003 if(interleaved_stats){
1164
0e3c0c4a7b3d msmpeg4 2pass support & some related cleanup
michaelni
parents: 1162
diff changeset
1004 s->misc_bits+= get_bits_diff(s);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1005 }
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
1006
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
1007 for(i=0; i<4; i++){
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
1008 /* motion vectors: 8x8 mode*/
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
1009 h263_pred_motion(s, i, &pred_x, &pred_y);
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
1010
1668
30746f429df6 move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents: 1666
diff changeset
1011 h263_encode_motion(s, s->current_picture.motion_val[0][ s->block_index[i] ][0] - pred_x, s->f_code);
30746f429df6 move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents: 1666
diff changeset
1012 h263_encode_motion(s, s->current_picture.motion_val[0][ s->block_index[i] ][1] - pred_y, s->f_code);
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
1013 }
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
1014 }
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1015
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1016 if(interleaved_stats){
1164
0e3c0c4a7b3d msmpeg4 2pass support & some related cleanup
michaelni
parents: 1162
diff changeset
1017 s->mv_bits+= get_bits_diff(s);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1018 }
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
1019
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
1020 /* encode each block */
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
1021 for (i = 0; i < 6; i++) {
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
1022 mpeg4_encode_block(s, block[i], i, 0, s->intra_scantable.permutated, NULL, tex_pb);
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
1023 }
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1024
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1025 if(interleaved_stats){
1164
0e3c0c4a7b3d msmpeg4 2pass support & some related cleanup
michaelni
parents: 1162
diff changeset
1026 s->p_tex_bits+= get_bits_diff(s);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1027 }
656
e47fa3e3f2d5 statistics for forw & back p-MBs instead of just one counter for both
michaelni
parents: 654
diff changeset
1028 s->f_count++;
295
6622b0fd036c mpeg4 4MV encoding
michaelni
parents: 294
diff changeset
1029 }
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1030 } else {
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
1031 int cbp;
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1032 int dc_diff[6]; //dc values with the dc prediction subtracted
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1033 int dir[6]; //prediction direction
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1034 int zigzag_last_index[6];
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
1035 uint8_t *scan_table[6];
1057
bb5de8a59da8 * static,const,compiler warning cleanup
kabi
parents: 1053
diff changeset
1036 int i;
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1037
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1038 for(i=0; i<6; i++){
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1039 const int level= block[i][0];
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
1040 uint16_t *dc_ptr;
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1041
498
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
1042 dc_diff[i]= level - ff_mpeg4_pred_dc(s, i, &dc_ptr, &dir[i]);
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1043 if (i < 4) {
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1044 *dc_ptr = level * s->y_dc_scale;
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1045 } else {
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1046 *dc_ptr = level * s->c_dc_scale;
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1047 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1048 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1049
1492
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
1050 if(s->flags & CODEC_FLAG_AC_PRED){
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
1051 s->ac_pred= decide_ac_pred(s, block, dir, scan_table, zigzag_last_index);
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
1052 if(!s->ac_pred)
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
1053 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
1054 }else{
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1055 for(i=0; i<6; i++)
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
1056 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
1057 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1058
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1059 /* compute cbp */
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1060 cbp = 0;
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1061 for (i = 0; i < 6; i++) {
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1062 if (s->block_last_index[i] >= 1)
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1063 cbp |= 1 << (5 - i);
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1064 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1065
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1066 cbpc = cbp & 3;
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1067 if (s->pict_type == I_TYPE) {
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
1068 if(s->dquant) cbpc+=4;
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1069 put_bits(&s->pb,
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1070 intra_MCBPC_bits[cbpc],
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1071 intra_MCBPC_code[cbpc]);
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1072 } else {
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
1073 if(s->dquant) cbpc+=8;
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1074 put_bits(&s->pb, 1, 0); /* mb coded */
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1075 put_bits(&s->pb,
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1076 inter_MCBPC_bits[cbpc + 4],
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1077 inter_MCBPC_code[cbpc + 4]);
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1078 }
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1079 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
1080 cbpy = cbp >> 2;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1081 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
1082 if(s->dquant)
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
1083 put_bits(dc_pb, 2, dquant_code[s->dquant+2]);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1084
697
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
1085 if(!s->progressive_sequence){
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
1086 put_bits(dc_pb, 1, s->interlaced_dct);
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
1087 }
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
1088
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1089 if(interleaved_stats){
1164
0e3c0c4a7b3d msmpeg4 2pass support & some related cleanup
michaelni
parents: 1162
diff changeset
1090 s->misc_bits+= get_bits_diff(s);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1091 }
286
91f7c38f5f37 statistics for 2-pass encoding
michaelni
parents: 285
diff changeset
1092
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1093 /* encode each block */
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1094 for (i = 0; i < 6; i++) {
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1095 mpeg4_encode_block(s, block[i], i, dc_diff[i], scan_table[i], dc_pb, tex_pb);
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1096 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1097
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1098 if(interleaved_stats){
1164
0e3c0c4a7b3d msmpeg4 2pass support & some related cleanup
michaelni
parents: 1162
diff changeset
1099 s->i_tex_bits+= get_bits_diff(s);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1100 }
286
91f7c38f5f37 statistics for 2-pass encoding
michaelni
parents: 285
diff changeset
1101 s->i_count++;
91f7c38f5f37 statistics for 2-pass encoding
michaelni
parents: 285
diff changeset
1102
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1103 /* restore ac coeffs & last_index stuff if we messed them up with the prediction */
1492
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
1104 if(s->ac_pred)
3518325146fc ac prediction cleanup
michaelni
parents: 1490
diff changeset
1105 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
1106 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1107 }
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
1108
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1109 void h263_encode_mb(MpegEncContext * s,
986e461dc072 Initial revision
glantau
parents:
diff changeset
1110 DCTELEM block[6][64],
986e461dc072 Initial revision
glantau
parents:
diff changeset
1111 int motion_x, int motion_y)
986e461dc072 Initial revision
glantau
parents:
diff changeset
1112 {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1113 int cbpc, cbpy, i, cbp, pred_x, pred_y;
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
1114 int16_t pred_dc;
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
1115 int16_t rec_intradc[6];
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
1116 uint16_t *dc_ptr[6];
1353
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
1117 const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1);
695
3525da287ee2 adaptive quantization for h263
michaelni
parents: 692
diff changeset
1118 const int dquant_code[5]= {1,0,9,2,3};
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1119
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1120 //printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
1121 if (!s->mb_intra) {
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1122 /* compute cbp */
1490
0355f2b3519a rate distortion optimal cbp support (h263/mpeg4 non intra only)
michaelni
parents: 1483
diff changeset
1123 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
1124
695
3525da287ee2 adaptive quantization for h263
michaelni
parents: 692
diff changeset
1125 if ((cbp | motion_x | motion_y | s->dquant) == 0) {
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
1126 /* skip macroblock */
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
1127 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
1128 if(interleaved_stats){
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
1129 s->misc_bits++;
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
1130 s->last_bits++;
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
1131 }
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
1132 return;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
1133 }
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1134 put_bits(&s->pb, 1, 0); /* mb coded */
1633
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
1135
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
1136 cbpc = cbp & 3;
1637
7799582dc9b8 h263 alternative inter vlc support
michael
parents: 1633
diff changeset
1137 cbpy = cbp >> 2;
7799582dc9b8 h263 alternative inter vlc support
michael
parents: 1633
diff changeset
1138 if(s->alt_inter_vlc==0 || cbpc!=3)
7799582dc9b8 h263 alternative inter vlc support
michael
parents: 1633
diff changeset
1139 cbpy ^= 0xF;
695
3525da287ee2 adaptive quantization for h263
michaelni
parents: 692
diff changeset
1140 if(s->dquant) cbpc+= 8;
1633
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
1141 if(s->mv_type==MV_TYPE_16X16){
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
1142 put_bits(&s->pb,
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
1143 inter_MCBPC_bits[cbpc],
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
1144 inter_MCBPC_code[cbpc]);
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
1145
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
1146 put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
1147 if(s->dquant)
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
1148 put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
1149
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
1150 if(interleaved_stats){
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
1151 s->misc_bits+= get_bits_diff(s);
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
1152 }
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
1153
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
1154 /* motion vectors: 16x16 mode */
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
1155 h263_pred_motion(s, 0, &pred_x, &pred_y);
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
1156
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
1157 if (!s->umvplus) {
1655
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
1158 h263_encode_motion(s, motion_x - pred_x, 1);
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
1159 h263_encode_motion(s, motion_y - pred_y, 1);
1633
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
1160 }
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
1161 else {
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
1162 h263p_encode_umotion(s, motion_x - pred_x);
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
1163 h263p_encode_umotion(s, motion_y - pred_y);
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
1164 if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
1165 /* To prevent Start Code emulation */
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
1166 put_bits(&s->pb,1,1);
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
1167 }
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
1168 }else{
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
1169 put_bits(&s->pb,
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
1170 inter_MCBPC_bits[cbpc+16],
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
1171 inter_MCBPC_code[cbpc+16]);
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
1172 put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
1173 if(s->dquant)
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
1174 put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
1175
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
1176 if(interleaved_stats){
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
1177 s->misc_bits+= get_bits_diff(s);
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
1178 }
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
1179
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
1180 for(i=0; i<4; i++){
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
1181 /* motion vectors: 8x8 mode*/
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
1182 h263_pred_motion(s, i, &pred_x, &pred_y);
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
1183
1668
30746f429df6 move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents: 1666
diff changeset
1184 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
1185 motion_y= s->current_picture.motion_val[0][ s->block_index[i] ][1];
1633
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
1186 if (!s->umvplus) {
1655
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
1187 h263_encode_motion(s, motion_x - pred_x, 1);
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
1188 h263_encode_motion(s, motion_y - pred_y, 1);
1633
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
1189 }
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
1190 else {
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
1191 h263p_encode_umotion(s, motion_x - pred_x);
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
1192 h263p_encode_umotion(s, motion_y - pred_y);
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
1193 if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
1194 /* To prevent Start Code emulation */
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
1195 put_bits(&s->pb,1,1);
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
1196 }
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
1197 }
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
1198 }
1353
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
1199
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
1200 if(interleaved_stats){
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
1201 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
1202 }
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1203 } else {
1639
3e2b774edce4 rv20 decoder
michael
parents: 1637
diff changeset
1204 assert(s->mb_intra);
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1205
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1206 cbp = 0;
1666
b76ab3c968ab AIC/MQ encoding fix
michael
parents: 1663
diff changeset
1207 if (s->h263_aic) {
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1208 /* Predict DC */
1666
b76ab3c968ab AIC/MQ encoding fix
michael
parents: 1663
diff changeset
1209 for(i=0; i<6; i++) {
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
1210 int16_t level = block[i][0];
1666
b76ab3c968ab AIC/MQ encoding fix
michael
parents: 1663
diff changeset
1211 int scale;
b76ab3c968ab AIC/MQ encoding fix
michael
parents: 1663
diff changeset
1212
b76ab3c968ab AIC/MQ encoding fix
michael
parents: 1663
diff changeset
1213 if(i<4) scale= s->y_dc_scale;
b76ab3c968ab AIC/MQ encoding fix
michael
parents: 1663
diff changeset
1214 else scale= s->c_dc_scale;
b76ab3c968ab AIC/MQ encoding fix
michael
parents: 1663
diff changeset
1215
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1216 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
1217 level -= pred_dc;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1218 /* Quant */
1666
b76ab3c968ab AIC/MQ encoding fix
michael
parents: 1663
diff changeset
1219 if (level >= 0)
b76ab3c968ab AIC/MQ encoding fix
michael
parents: 1663
diff changeset
1220 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
1221 else
1666
b76ab3c968ab AIC/MQ encoding fix
michael
parents: 1663
diff changeset
1222 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
1223
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1224 /* AIC can change CBP */
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1225 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
1226 s->block_last_index[i] = -1;
1666
b76ab3c968ab AIC/MQ encoding fix
michael
parents: 1663
diff changeset
1227
b76ab3c968ab AIC/MQ encoding fix
michael
parents: 1663
diff changeset
1228 if(!s->modified_quant){
b76ab3c968ab AIC/MQ encoding fix
michael
parents: 1663
diff changeset
1229 if (level < -127)
b76ab3c968ab AIC/MQ encoding fix
michael
parents: 1663
diff changeset
1230 level = -127;
b76ab3c968ab AIC/MQ encoding fix
michael
parents: 1663
diff changeset
1231 else if (level > 127)
b76ab3c968ab AIC/MQ encoding fix
michael
parents: 1663
diff changeset
1232 level = 127;
b76ab3c968ab AIC/MQ encoding fix
michael
parents: 1663
diff changeset
1233 }
b76ab3c968ab AIC/MQ encoding fix
michael
parents: 1663
diff changeset
1234
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1235 block[i][0] = level;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1236 /* Reconstruction */
1666
b76ab3c968ab AIC/MQ encoding fix
michael
parents: 1663
diff changeset
1237 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
1238 /* Oddify */
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1239 rec_intradc[i] |= 1;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1240 //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
1241 // rec_intradc[i]++;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1242 /* Clipping */
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1243 if (rec_intradc[i] < 0)
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1244 rec_intradc[i] = 0;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1245 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
1246 rec_intradc[i] = 2047;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1247
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1248 /* Update AC/DC tables */
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1249 *dc_ptr[i] = rec_intradc[i];
1666
b76ab3c968ab AIC/MQ encoding fix
michael
parents: 1663
diff changeset
1250 if (s->block_last_index[i] >= 0)
b76ab3c968ab AIC/MQ encoding fix
michael
parents: 1663
diff changeset
1251 cbp |= 1 << (5 - i);
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1252 }
1666
b76ab3c968ab AIC/MQ encoding fix
michael
parents: 1663
diff changeset
1253 }else{
b76ab3c968ab AIC/MQ encoding fix
michael
parents: 1663
diff changeset
1254 for(i=0; i<6; i++) {
b76ab3c968ab AIC/MQ encoding fix
michael
parents: 1663
diff changeset
1255 /* compute cbp */
b76ab3c968ab AIC/MQ encoding fix
michael
parents: 1663
diff changeset
1256 if (s->block_last_index[i] >= 1)
b76ab3c968ab AIC/MQ encoding fix
michael
parents: 1663
diff changeset
1257 cbp |= 1 << (5 - i);
b76ab3c968ab AIC/MQ encoding fix
michael
parents: 1663
diff changeset
1258 }
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1259 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1260
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1261 cbpc = cbp & 3;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1262 if (s->pict_type == I_TYPE) {
695
3525da287ee2 adaptive quantization for h263
michaelni
parents: 692
diff changeset
1263 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
1264 put_bits(&s->pb,
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1265 intra_MCBPC_bits[cbpc],
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1266 intra_MCBPC_code[cbpc]);
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1267 } else {
695
3525da287ee2 adaptive quantization for h263
michaelni
parents: 692
diff changeset
1268 if(s->dquant) cbpc+=8;
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1269 put_bits(&s->pb, 1, 0); /* mb coded */
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1270 put_bits(&s->pb,
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1271 inter_MCBPC_bits[cbpc + 4],
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1272 inter_MCBPC_code[cbpc + 4]);
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1273 }
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1274 if (s->h263_aic) {
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1275 /* XXX: currently, we do not try to use ac prediction */
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1276 put_bits(&s->pb, 1, 0); /* no AC prediction */
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1277 }
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1278 cbpy = cbp >> 2;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1279 put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
695
3525da287ee2 adaptive quantization for h263
michaelni
parents: 692
diff changeset
1280 if(s->dquant)
3525da287ee2 adaptive quantization for h263
michaelni
parents: 692
diff changeset
1281 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
1282
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
1283 if(interleaved_stats){
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
1284 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
1285 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1286 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1287
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1288 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
1289 /* encode each block */
1354
1f89adb69349 flv cleanup / simplify
michaelni
parents: 1353
diff changeset
1290 h263_encode_block(s, block[i], i);
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1291
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1292 /* Update INTRADC for decoding */
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1293 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
1294 block[i][0] = rec_intradc[i];
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1295
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1296 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1297 }
1353
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
1298
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
1299 if(interleaved_stats){
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
1300 if (!s->mb_intra) {
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
1301 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
1302 s->f_count++;
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
1303 }else{
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
1304 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
1305 s->i_count++;
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
1306 }
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
1307 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1308 }
815
78accc54493b put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents: 770
diff changeset
1309 #endif
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1310
1656
34b0e799aeb6 cleanup
michael
parents: 1655
diff changeset
1311 void ff_h263_loop_filter(MpegEncContext * s){
1644
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1312 int qp_c;
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1313 const int linesize = s->linesize;
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1314 const int uvlinesize= s->uvlinesize;
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1315 const int xy = s->mb_y * s->mb_stride + s->mb_x;
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1316 uint8_t *dest_y = s->dest[0];
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1317 uint8_t *dest_cb= s->dest[1];
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1318 uint8_t *dest_cr= s->dest[2];
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1319
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1320 // if(s->pict_type==B_TYPE && !s->readable) return;
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1321
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1322 /*
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1323 Diag Top
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1324 Left Center
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1325 */
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1326 if(!IS_SKIP(s->current_picture.mb_type[xy])){
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1327 qp_c= s->qscale;
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1328 s->dsp.h263_v_loop_filter(dest_y+8*linesize , linesize, qp_c);
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1329 s->dsp.h263_v_loop_filter(dest_y+8*linesize+8, linesize, qp_c);
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1330 }else
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1331 qp_c= 0;
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1332
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1333 if(s->mb_y){
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1334 int qp_dt, qp_t, qp_tc;
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1335
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1336 if(IS_SKIP(s->current_picture.mb_type[xy-s->mb_stride]))
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1337 qp_t=0;
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1338 else
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1339 qp_t= s->current_picture.qscale_table[xy-s->mb_stride];
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1340
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1341 if(qp_c)
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1342 qp_tc= qp_c;
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1343 else
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1344 qp_tc= qp_t;
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1345
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1346 if(qp_tc){
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1347 const int chroma_qp= s->chroma_qscale_table[qp_tc];
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1348 s->dsp.h263_v_loop_filter(dest_y , linesize, qp_tc);
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1349 s->dsp.h263_v_loop_filter(dest_y+8, linesize, qp_tc);
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1350
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1351 s->dsp.h263_v_loop_filter(dest_cb , uvlinesize, chroma_qp);
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1352 s->dsp.h263_v_loop_filter(dest_cr , uvlinesize, chroma_qp);
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1353 }
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1354
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1355 if(qp_t)
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1356 s->dsp.h263_h_loop_filter(dest_y-8*linesize+8 , linesize, qp_t);
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1357
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1358 if(s->mb_x){
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1359 if(qp_t || IS_SKIP(s->current_picture.mb_type[xy-1-s->mb_stride]))
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1360 qp_dt= qp_t;
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1361 else
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1362 qp_dt= s->current_picture.qscale_table[xy-1-s->mb_stride];
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1363
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1364 if(qp_dt){
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1365 const int chroma_qp= s->chroma_qscale_table[qp_dt];
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1366 s->dsp.h263_h_loop_filter(dest_y -8*linesize , linesize, qp_dt);
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1367 s->dsp.h263_h_loop_filter(dest_cb-8*uvlinesize, uvlinesize, chroma_qp);
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1368 s->dsp.h263_h_loop_filter(dest_cb-8*uvlinesize, uvlinesize, chroma_qp);
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1369 }
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1370 }
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1371 }
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1372
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1373 if(qp_c){
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1374 s->dsp.h263_h_loop_filter(dest_y +8, linesize, qp_c);
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1375 if(s->mb_y + 1 == s->mb_height)
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1376 s->dsp.h263_h_loop_filter(dest_y+8*linesize+8, linesize, qp_c);
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1377 }
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1378
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1379 if(s->mb_x){
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1380 int qp_lc;
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1381 if(qp_c || IS_SKIP(s->current_picture.mb_type[xy-1]))
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1382 qp_lc= qp_c;
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1383 else
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1384 qp_lc= s->current_picture.qscale_table[xy-1];
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1385
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1386 if(qp_lc){
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1387 s->dsp.h263_h_loop_filter(dest_y, linesize, qp_lc);
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1388 if(s->mb_y + 1 == s->mb_height){
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1389 const int chroma_qp= s->chroma_qscale_table[qp_lc];
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1390 s->dsp.h263_h_loop_filter(dest_y +8* linesize, linesize, qp_lc);
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1391 s->dsp.h263_h_loop_filter(dest_cb , uvlinesize, chroma_qp);
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1392 s->dsp.h263_h_loop_filter(dest_cr , uvlinesize, chroma_qp);
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1393 }
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1394 }
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1395 }
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1396 }
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
1397
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
1398 static int h263_pred_dc(MpegEncContext * s, int n, uint16_t **dc_val_ptr)
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1399 {
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1400 int x, y, wrap, a, c, pred_dc, scale;
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
1401 int16_t *dc_val, *ac_val;
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1402
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1403 /* find prediction */
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1404 if (n < 4) {
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1405 x = 2 * s->mb_x + 1 + (n & 1);
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1406 y = 2 * s->mb_y + 1 + ((n & 2) >> 1);
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1407 wrap = s->mb_width * 2 + 2;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1408 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
1409 ac_val = s->ac_val[0][0];
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1410 scale = s->y_dc_scale;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1411 } else {
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1412 x = s->mb_x + 1;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1413 y = s->mb_y + 1;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1414 wrap = s->mb_width + 2;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1415 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
1416 ac_val = s->ac_val[n - 4 + 1][0];
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1417 scale = s->c_dc_scale;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1418 }
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1419 /* B C
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1420 * A X
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1421 */
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1422 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
1423 c = dc_val[(x) + (y - 1) * wrap];
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1424
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1425 /* No prediction outside GOB boundary */
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1426 if (s->first_slice_line && ((n < 2) || (n > 3)))
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1427 c = 1024;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1428 pred_dc = 1024;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1429 /* just DC prediction */
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1430 if (a != 1024 && c != 1024)
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1431 pred_dc = (a + c) >> 1;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1432 else if (a != 1024)
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1433 pred_dc = a;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1434 else
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1435 pred_dc = c;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1436
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1437 /* we assume pred is positive */
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1438 //pred_dc = (pred_dc + (scale >> 1)) / scale;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1439 *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
1440 return pred_dc;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1441 }
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1442
1057
bb5de8a59da8 * static,const,compiler warning cleanup
kabi
parents: 1053
diff changeset
1443 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
1444 {
249
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1445 int x, y, wrap, a, c, pred_dc, scale, i;
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
1446 int16_t *dc_val, *ac_val, *ac_val1;
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1447
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1448 /* find prediction */
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1449 if (n < 4) {
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1450 x = 2 * s->mb_x + 1 + (n & 1);
1639
3e2b774edce4 rv20 decoder
michael
parents: 1637
diff changeset
1451 y = 2 * s->mb_y + 1 + (n>> 1);
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1452 wrap = s->mb_width * 2 + 2;
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1453 dc_val = s->dc_val[0];
249
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1454 ac_val = s->ac_val[0][0];
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1455 scale = s->y_dc_scale;
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1456 } else {
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1457 x = s->mb_x + 1;
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1458 y = s->mb_y + 1;
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1459 wrap = s->mb_width + 2;
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1460 dc_val = s->dc_val[n - 4 + 1];
249
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1461 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
1462 scale = s->c_dc_scale;
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1463 }
249
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1464
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1465 ac_val += ((y) * wrap + (x)) * 16;
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1466 ac_val1 = ac_val;
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1467
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1468 /* B C
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1469 * A X
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1470 */
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1471 a = dc_val[(x - 1) + (y) * wrap];
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1472 c = dc_val[(x) + (y - 1) * wrap];
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1473
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1474 /* No prediction outside GOB boundary */
1639
3e2b774edce4 rv20 decoder
michael
parents: 1637
diff changeset
1475 if(s->first_slice_line && n!=3){
3e2b774edce4 rv20 decoder
michael
parents: 1637
diff changeset
1476 if(n!=2) c= 1024;
3e2b774edce4 rv20 decoder
michael
parents: 1637
diff changeset
1477 if(n!=1 && s->mb_x == s->resync_mb_x) a= 1024;
3e2b774edce4 rv20 decoder
michael
parents: 1637
diff changeset
1478 }
3e2b774edce4 rv20 decoder
michael
parents: 1637
diff changeset
1479
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1480 if (s->ac_pred) {
1639
3e2b774edce4 rv20 decoder
michael
parents: 1637
diff changeset
1481 pred_dc = 1024;
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1482 if (s->h263_aic_dir) {
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1483 /* left prediction */
249
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1484 if (a != 1024) {
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1485 ac_val -= 16;
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1486 for(i=1;i<8;i++) {
1092
f59c3f66363b MpegEncContext.(i)dct_* -> DspContext.(i)dct_*
michaelni
parents: 1090
diff changeset
1487 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
1488 }
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1489 pred_dc = a;
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1490 }
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1491 } else {
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1492 /* top prediction */
249
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1493 if (c != 1024) {
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1494 ac_val -= 16 * wrap;
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1495 for(i=1;i<8;i++) {
1092
f59c3f66363b MpegEncContext.(i)dct_* -> DspContext.(i)dct_*
michaelni
parents: 1090
diff changeset
1496 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
1497 }
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1498 pred_dc = c;
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1499 }
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1500 }
249
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1501 } else {
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1502 /* just DC prediction */
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1503 if (a != 1024 && c != 1024)
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1504 pred_dc = (a + c) >> 1;
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1505 else if (a != 1024)
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1506 pred_dc = a;
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1507 else
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1508 pred_dc = c;
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1509 }
249
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1510
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1511 /* we assume pred is positive */
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1512 block[0]=block[0]*scale + pred_dc;
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1513
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1514 if (block[0] < 0)
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1515 block[0] = 0;
1639
3e2b774edce4 rv20 decoder
michael
parents: 1637
diff changeset
1516 else
3e2b774edce4 rv20 decoder
michael
parents: 1637
diff changeset
1517 block[0] |= 1;
249
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1518
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1519 /* Update AC/DC tables */
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1520 dc_val[(x) + (y) * wrap] = block[0];
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
1521
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1522 /* left copy */
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1523 for(i=1;i<8;i++)
1092
f59c3f66363b MpegEncContext.(i)dct_* -> DspContext.(i)dct_*
michaelni
parents: 1090
diff changeset
1524 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
1525 /* top copy */
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1526 for(i=1;i<8;i++)
1092
f59c3f66363b MpegEncContext.(i)dct_* -> DspContext.(i)dct_*
michaelni
parents: 1090
diff changeset
1527 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
1528 }
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
1529
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
1530 int16_t *h263_pred_motion(MpegEncContext * s, int block,
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1531 int *px, int *py)
986e461dc072 Initial revision
glantau
parents:
diff changeset
1532 {
266
252444e5259b optimization
michaelni
parents: 265
diff changeset
1533 int xy, wrap;
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
1534 int16_t *A, *B, *C, *mot_val;
264
28c5c62b1c4c support decoding (with mplayer) of 3 .mp4 files from mphq
michaelni
parents: 263
diff changeset
1535 static const int off[4]= {2, 1, 1, -1};
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1536
266
252444e5259b optimization
michaelni
parents: 265
diff changeset
1537 wrap = s->block_wrap[0];
252444e5259b optimization
michaelni
parents: 265
diff changeset
1538 xy = s->block_index[block];
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1539
1668
30746f429df6 move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents: 1666
diff changeset
1540 mot_val = s->current_picture.motion_val[0][xy];
30746f429df6 move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents: 1666
diff changeset
1541
30746f429df6 move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents: 1666
diff changeset
1542 A = s->current_picture.motion_val[0][xy - 1];
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1543 /* special case for first (slice) line */
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
1544 if (s->first_slice_line && block<3) {
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1545 // we cant just change some MVs to simulate that as we need them for the B frames (and ME)
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1546 // and if we ever support non rectangular objects than we need to do a few ifs here anyway :(
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1547 if(block==0){ //most common case
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1548 if(s->mb_x == s->resync_mb_x){ //rare
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1549 *px= *py = 0;
1646
c3c166ead03a h263 MV prediction doesnt match mpeg4, for some slices configurations (fixes RV20 MVs)
michael
parents: 1644
diff changeset
1550 }else if(s->mb_x + 1 == s->resync_mb_x && s->h263_pred){ //rare
1668
30746f429df6 move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents: 1666
diff changeset
1551 C = s->current_picture.motion_val[0][xy + off[block] - wrap];
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1552 if(s->mb_x==0){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1553 *px = C[0];
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1554 *py = C[1];
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1555 }else{
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1556 *px = mid_pred(A[0], 0, C[0]);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1557 *py = mid_pred(A[1], 0, C[1]);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1558 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1559 }else{
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1560 *px = A[0];
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1561 *py = A[1];
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1562 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1563 }else if(block==1){
1646
c3c166ead03a h263 MV prediction doesnt match mpeg4, for some slices configurations (fixes RV20 MVs)
michael
parents: 1644
diff changeset
1564 if(s->mb_x + 1 == s->resync_mb_x && s->h263_pred){ //rare
1668
30746f429df6 move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents: 1666
diff changeset
1565 C = s->current_picture.motion_val[0][xy + off[block] - wrap];
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1566 *px = mid_pred(A[0], 0, C[0]);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1567 *py = mid_pred(A[1], 0, C[1]);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1568 }else{
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1569 *px = A[0];
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1570 *py = A[1];
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1571 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1572 }else{ /* block==2*/
1668
30746f429df6 move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents: 1666
diff changeset
1573 B = s->current_picture.motion_val[0][xy - wrap];
30746f429df6 move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents: 1666
diff changeset
1574 C = s->current_picture.motion_val[0][xy + off[block] - wrap];
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1575 if(s->mb_x == s->resync_mb_x) //rare
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1576 A[0]=A[1]=0;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1577
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1578 *px = mid_pred(A[0], B[0], C[0]);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1579 *py = mid_pred(A[1], B[1], C[1]);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
1580 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1581 } else {
1668
30746f429df6 move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents: 1666
diff changeset
1582 B = s->current_picture.motion_val[0][xy - wrap];
30746f429df6 move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents: 1666
diff changeset
1583 C = s->current_picture.motion_val[0][xy + off[block] - wrap];
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1584 *px = mid_pred(A[0], B[0], C[0]);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1585 *py = mid_pred(A[1], B[1], C[1]);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1586 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1587 return mot_val;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1588 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1589
1655
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
1590 // identical to above but with s->current_picture->motion_val, the above one will be removed, and this renamed to it
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
1591 int16_t *h263_pred_motion2(MpegEncContext * s, int block, int dir,
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
1592 int *px, int *py)
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
1593 {
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
1594 int xy, wrap;
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
1595 int16_t *A, *B, *C, (*mot_val)[2];
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
1596 static const int off[4]= {2, 1, 1, -1};
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
1597
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
1598 wrap = s->b8_stride;
1701
95b7ac3344df rv20 / h263 b frame fix
michael
parents: 1680
diff changeset
1599 xy = 2*(s->mb_x + s->mb_y * wrap);
95b7ac3344df rv20 / h263 b frame fix
michael
parents: 1680
diff changeset
1600
95b7ac3344df rv20 / h263 b frame fix
michael
parents: 1680
diff changeset
1601 mot_val = s->current_picture.motion_val[dir] + xy;
1655
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
1602
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
1603 A = mot_val[ - 1];
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
1604 /* special case for first (slice) line */
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
1605 if (s->first_slice_line && block<3) {
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
1606 // we cant just change some MVs to simulate that as we need them for the B frames (and ME)
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
1607 // and if we ever support non rectangular objects than we need to do a few ifs here anyway :(
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
1608 if(block==0){ //most common case
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
1609 if(s->mb_x == s->resync_mb_x){ //rare
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
1610 *px= *py = 0;
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
1611 }else if(s->mb_x + 1 == s->resync_mb_x && s->h263_pred){ //rare
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
1612 C = mot_val[off[block] - wrap];
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
1613 if(s->mb_x==0){
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
1614 *px = C[0];
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
1615 *py = C[1];
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
1616 }else{
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
1617 *px = mid_pred(A[0], 0, C[0]);
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
1618 *py = mid_pred(A[1], 0, C[1]);
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
1619 }
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
1620 }else{
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
1621 *px = A[0];
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
1622 *py = A[1];
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
1623 }
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
1624 }else if(block==1){
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
1625 if(s->mb_x + 1 == s->resync_mb_x && s->h263_pred){ //rare
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
1626 C = mot_val[off[block] - wrap];
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
1627 *px = mid_pred(A[0], 0, C[0]);
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
1628 *py = mid_pred(A[1], 0, C[1]);
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
1629 }else{
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
1630 *px = A[0];
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
1631 *py = A[1];
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
1632 }
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
1633 }else{ /* block==2*/
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
1634 B = mot_val[ - wrap];
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
1635 C = mot_val[off[block] - wrap];
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
1636 if(s->mb_x == s->resync_mb_x) //rare
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
1637 A[0]=A[1]=0;
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
1638
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
1639 *px = mid_pred(A[0], B[0], C[0]);
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
1640 *py = mid_pred(A[1], B[1], C[1]);
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
1641 }
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
1642 } else {
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
1643 B = mot_val[ - wrap];
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
1644 C = mot_val[off[block] - wrap];
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
1645 *px = mid_pred(A[0], B[0], C[0]);
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
1646 *py = mid_pred(A[1], B[1], C[1]);
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
1647 }
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
1648 return *mot_val;
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
1649 }
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
1650
815
78accc54493b put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents: 770
diff changeset
1651 #ifdef CONFIG_ENCODERS
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
1652 static void h263_encode_motion(MpegEncContext * s, int val, int f_code)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1653 {
702
2cff6fc37716 minor optimization of h263_encode_motion()
michaelni
parents: 701
diff changeset
1654 int range, l, bit_size, sign, code, bits;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1655
986e461dc072 Initial revision
glantau
parents:
diff changeset
1656 if (val == 0) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1657 /* zero vector */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1658 code = 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1659 put_bits(&s->pb, mvtab[code][1], mvtab[code][0]);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1660 } else {
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
1661 bit_size = f_code - 1;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1662 range = 1 << bit_size;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1663 /* modulo encoding */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1664 l = range * 32;
702
2cff6fc37716 minor optimization of h263_encode_motion()
michaelni
parents: 701
diff changeset
1665 #if 1
2cff6fc37716 minor optimization of h263_encode_motion()
michaelni
parents: 701
diff changeset
1666 val+= l;
2cff6fc37716 minor optimization of h263_encode_motion()
michaelni
parents: 701
diff changeset
1667 val&= 2*l-1;
2cff6fc37716 minor optimization of h263_encode_motion()
michaelni
parents: 701
diff changeset
1668 val-= l;
2cff6fc37716 minor optimization of h263_encode_motion()
michaelni
parents: 701
diff changeset
1669 sign = val>>31;
2cff6fc37716 minor optimization of h263_encode_motion()
michaelni
parents: 701
diff changeset
1670 val= (val^sign)-sign;
2cff6fc37716 minor optimization of h263_encode_motion()
michaelni
parents: 701
diff changeset
1671 sign&=1;
2cff6fc37716 minor optimization of h263_encode_motion()
michaelni
parents: 701
diff changeset
1672 #else
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1673 if (val < -l) {
702
2cff6fc37716 minor optimization of h263_encode_motion()
michaelni
parents: 701
diff changeset
1674 val += 2*l;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1675 } else if (val >= l) {
702
2cff6fc37716 minor optimization of h263_encode_motion()
michaelni
parents: 701
diff changeset
1676 val -= 2*l;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1677 }
702
2cff6fc37716 minor optimization of h263_encode_motion()
michaelni
parents: 701
diff changeset
1678
690
a1c69cb685b3 adaptive quantization (lumi/temporal & spatial complexity masking)
michaelni
parents: 676
diff changeset
1679 assert(val>=-l && val<l);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1680
986e461dc072 Initial revision
glantau
parents:
diff changeset
1681 if (val >= 0) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1682 sign = 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1683 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1684 val = -val;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1685 sign = 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1686 }
702
2cff6fc37716 minor optimization of h263_encode_motion()
michaelni
parents: 701
diff changeset
1687 #endif
312
8cf5507e6ca5 mpeg4 mpeg quantizer support
michaelni
parents: 301
diff changeset
1688 val--;
8cf5507e6ca5 mpeg4 mpeg quantizer support
michaelni
parents: 301
diff changeset
1689 code = (val >> bit_size) + 1;
8cf5507e6ca5 mpeg4 mpeg quantizer support
michaelni
parents: 301
diff changeset
1690 bits = val & (range - 1);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1691
986e461dc072 Initial revision
glantau
parents:
diff changeset
1692 put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1693 if (bit_size > 0) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1694 put_bits(&s->pb, bit_size, bits);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1695 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1696 }
718
16dab8296293 fixing custom quantizer matrix decoding
michaelni
parents: 706
diff changeset
1697
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1698 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1699
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1700 /* Encode MV differences on H.263+ with Unrestricted MV mode */
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1701 static void h263p_encode_umotion(MpegEncContext * s, int val)
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1702 {
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1703 short sval = 0;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1704 short i = 0;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1705 short n_bits = 0;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1706 short temp_val;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1707 int code = 0;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1708 int tcode;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1709
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1710 if ( val == 0)
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1711 put_bits(&s->pb, 1, 1);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1712 else if (val == 1)
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1713 put_bits(&s->pb, 3, 0);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1714 else if (val == -1)
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1715 put_bits(&s->pb, 3, 2);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1716 else {
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1717
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1718 sval = ((val < 0) ? (short)(-val):(short)val);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1719 temp_val = sval;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1720
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1721 while (temp_val != 0) {
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1722 temp_val = temp_val >> 1;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1723 n_bits++;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1724 }
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1725
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1726 i = n_bits - 1;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1727 while (i > 0) {
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1728 tcode = (sval & (1 << (i-1))) >> (i-1);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1729 tcode = (tcode << 1) | 1;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1730 code = (code << 2) | tcode;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1731 i--;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1732 }
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1733 code = ((code << 1) | (val < 0)) << 1;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1734 put_bits(&s->pb, (2*n_bits)+1, code);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1735 //printf("\nVal = %d\tCode = %d", sval, code);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1736 }
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1737 }
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
1738
277
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1739 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
1740 {
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1741 int f_code;
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1742 int mv;
815
78accc54493b put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents: 770
diff changeset
1743
78accc54493b put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents: 770
diff changeset
1744 if(mv_penalty==NULL)
1162
8c15d82c1893 some static -> dynamic alloc & 16->8 bit
michaelni
parents: 1150
diff changeset
1745 mv_penalty= av_mallocz( sizeof(uint8_t)*(MAX_FCODE+1)*(2*MAX_MV+1) );
815
78accc54493b put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents: 770
diff changeset
1746
277
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1747 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
1748 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
1749 int len;
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1750
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1751 if(mv==0) len= mvtab[0][1];
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1752 else{
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1753 int val, bit_size, range, code;
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1754
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1755 bit_size = s->f_code - 1;
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1756 range = 1 << bit_size;
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1757
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1758 val=mv;
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1759 if (val < 0)
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1760 val = -val;
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1761 val--;
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1762 code = (val >> bit_size) + 1;
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1763 if(code<33){
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1764 len= mvtab[code][1] + 1 + bit_size;
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1765 }else{
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1766 len= mvtab[32][1] + 2 + bit_size;
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1767 }
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1768 }
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1769
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1770 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
1771 }
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1772 }
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1773
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1774 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
1775 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
1776 fcode_tab[mv+MAX_MV]= f_code;
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1777 }
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1778 }
287
32a3dcce2e9b fixing motion estimation with h263p hopefully
michaelni
parents: 286
diff changeset
1779
32a3dcce2e9b fixing motion estimation with h263p hopefully
michaelni
parents: 286
diff changeset
1780 for(mv=0; mv<MAX_MV*2+1; mv++){
32a3dcce2e9b fixing motion estimation with h263p hopefully
michaelni
parents: 286
diff changeset
1781 umv_fcode_tab[mv]= 1;
32a3dcce2e9b fixing motion estimation with h263p hopefully
michaelni
parents: 286
diff changeset
1782 }
277
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1783 }
815
78accc54493b put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents: 770
diff changeset
1784 #endif
277
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1785
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
1786 #ifdef CONFIG_ENCODERS
6da5ae9ee199 more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents: 1068
diff changeset
1787
468
1e23eae32087 Minor warning cleanup.
mellum
parents: 453
diff changeset
1788 static void init_uni_dc_tab(void)
293
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1789 {
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1790 int level, uni_code, uni_len;
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1791
312
8cf5507e6ca5 mpeg4 mpeg quantizer support
michaelni
parents: 301
diff changeset
1792 for(level=-256; level<256; level++){
293
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1793 int size, v, l;
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1794 /* find number of bits */
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1795 size = 0;
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1796 v = abs(level);
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1797 while (v) {
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1798 v >>= 1;
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1799 size++;
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1800 }
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1801
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1802 if (level < 0)
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1803 l= (-level) ^ ((1 << size) - 1);
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1804 else
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1805 l= level;
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1806
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1807 /* luminance */
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1808 uni_code= DCtab_lum[size][0];
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1809 uni_len = DCtab_lum[size][1];
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1810
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1811 if (size > 0) {
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1812 uni_code<<=size; uni_code|=l;
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1813 uni_len+=size;
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1814 if (size > 8){
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1815 uni_code<<=1; uni_code|=1;
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1816 uni_len++;
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1817 }
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1818 }
1013
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1008
diff changeset
1819 uni_DCtab_lum_bits[level+256]= uni_code;
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1008
diff changeset
1820 uni_DCtab_lum_len [level+256]= uni_len;
293
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1821
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1822 /* chrominance */
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1823 uni_code= DCtab_chrom[size][0];
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1824 uni_len = DCtab_chrom[size][1];
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1825
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1826 if (size > 0) {
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1827 uni_code<<=size; uni_code|=l;
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1828 uni_len+=size;
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1829 if (size > 8){
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1830 uni_code<<=1; uni_code|=1;
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1831 uni_len++;
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1832 }
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1833 }
1013
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1008
diff changeset
1834 uni_DCtab_chrom_bits[level+256]= uni_code;
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1008
diff changeset
1835 uni_DCtab_chrom_len [level+256]= uni_len;
293
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1836
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1837 }
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1838 }
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1839
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
1840 #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
1841
815
78accc54493b put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents: 770
diff changeset
1842 #ifdef CONFIG_ENCODERS
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
1843 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
1844 int slevel, run, last;
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1845
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1846 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
1847 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
1848
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1849 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
1850 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
1851 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
1852 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
1853 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
1854 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
1855 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
1856 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
1857 int level1, run1;
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1858
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1859 len_tab[index]= 100;
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1860
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1861 /* 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
1862 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
1863 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
1864 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
1865 bits=bits*2+sign; len++;
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1866
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1867 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
1868 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
1869 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
1870 }
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1871 #if 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
1872 /* 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
1873 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
1874 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
1875 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
1876 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
1877 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
1878 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
1879 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
1880 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
1881 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
1882 bits=bits*2+sign; len++;
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1883
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1884 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
1885 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
1886 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
1887 }
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1888 }
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream 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 #endif
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1890 #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
1891 /* 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
1892 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
1893 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
1894 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
1895 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
1896 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
1897 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
1898 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
1899 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
1900 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
1901 bits=bits*2+sign; len++;
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1902
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1903 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
1904 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
1905 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
1906 }
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1907 }
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1908 #endif
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1909 /* 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
1910 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
1911 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
1912 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
1913 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
1914 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
1915 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
1916 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
1917 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
1918
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream 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(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
1920 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
1921 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
1922 }
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream 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 }
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream 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 }
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1925 }
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream 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 }
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream 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
277
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1928 void h263_encode_init(MpegEncContext *s)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1929 {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1930 static int done = 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1931
986e461dc072 Initial revision
glantau
parents:
diff changeset
1932 if (!done) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1933 done = 1;
293
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1934
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1935 init_uni_dc_tab();
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
1936
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1937 init_rl(&rl_inter);
986e461dc072 Initial revision
glantau
parents:
diff changeset
1938 init_rl(&rl_intra);
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
1939 init_rl(&rl_intra_aic);
648
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
1940
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream 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 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
1942 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
1943
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1944 init_mv_penalty_and_fcode(s);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1945 }
936
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
1946 s->me.mv_penalty= mv_penalty; //FIXME exact table for msmpeg4 & h263p
277
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 274
diff changeset
1947
287
32a3dcce2e9b fixing motion estimation with h263p hopefully
michaelni
parents: 286
diff changeset
1948 // use fcodes >1 only for mpeg4 & h263 & h263p FIXME
344
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
1949 switch(s->codec_id){
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
1950 case CODEC_ID_MPEG4:
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
1951 s->fcode_tab= fcode_tab;
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
1952 s->min_qcoeff= -2048;
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
1953 s->max_qcoeff= 2047;
945
463f7260b155 trellis quantization
michaelni
parents: 942
diff changeset
1954 s->intra_ac_vlc_length = uni_mpeg4_intra_rl_len;
463f7260b155 trellis quantization
michaelni
parents: 942
diff changeset
1955 s->intra_ac_vlc_last_length= uni_mpeg4_intra_rl_len + 128*64;
463f7260b155 trellis quantization
michaelni
parents: 942
diff changeset
1956 s->inter_ac_vlc_length = uni_mpeg4_inter_rl_len;
463f7260b155 trellis quantization
michaelni
parents: 942
diff changeset
1957 s->inter_ac_vlc_last_length= uni_mpeg4_inter_rl_len + 128*64;
1013
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1008
diff changeset
1958 s->luma_dc_vlc_length= uni_DCtab_lum_len;
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1008
diff changeset
1959 s->chroma_dc_vlc_length= uni_DCtab_chrom_len;
945
463f7260b155 trellis quantization
michaelni
parents: 942
diff changeset
1960 s->ac_esc_length= 7+2+1+6+1+12+1;
1424
39ebefd82728 fixing CODEC_FLAG_GLOBAL_HEADER
michaelni
parents: 1419
diff changeset
1961
39ebefd82728 fixing CODEC_FLAG_GLOBAL_HEADER
michaelni
parents: 1419
diff changeset
1962 if(s->flags & CODEC_FLAG_GLOBAL_HEADER){
1483
michaelni
parents: 1482
diff changeset
1963
1424
39ebefd82728 fixing CODEC_FLAG_GLOBAL_HEADER
michaelni
parents: 1419
diff changeset
1964 s->avctx->extradata= av_malloc(1024);
1522
79dddc5cd990 removed the obsolete and unused parameters of init_put_bits
alex
parents: 1521
diff changeset
1965 init_put_bits(&s->pb, s->avctx->extradata, 1024);
1424
39ebefd82728 fixing CODEC_FLAG_GLOBAL_HEADER
michaelni
parents: 1419
diff changeset
1966
39ebefd82728 fixing CODEC_FLAG_GLOBAL_HEADER
michaelni
parents: 1419
diff changeset
1967 mpeg4_encode_visual_object_header(s);
39ebefd82728 fixing CODEC_FLAG_GLOBAL_HEADER
michaelni
parents: 1419
diff changeset
1968 mpeg4_encode_vol_header(s, 0, 0);
39ebefd82728 fixing CODEC_FLAG_GLOBAL_HEADER
michaelni
parents: 1419
diff changeset
1969
39ebefd82728 fixing CODEC_FLAG_GLOBAL_HEADER
michaelni
parents: 1419
diff changeset
1970 // ff_mpeg4_stuffing(&s->pb); ?
39ebefd82728 fixing CODEC_FLAG_GLOBAL_HEADER
michaelni
parents: 1419
diff changeset
1971 flush_put_bits(&s->pb);
39ebefd82728 fixing CODEC_FLAG_GLOBAL_HEADER
michaelni
parents: 1419
diff changeset
1972 s->avctx->extradata_size= (get_bit_count(&s->pb)+7)>>3;
39ebefd82728 fixing CODEC_FLAG_GLOBAL_HEADER
michaelni
parents: 1419
diff changeset
1973 }
39ebefd82728 fixing CODEC_FLAG_GLOBAL_HEADER
michaelni
parents: 1419
diff changeset
1974
344
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
1975 break;
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
1976 case CODEC_ID_H263P:
1666
b76ab3c968ab AIC/MQ encoding fix
michael
parents: 1663
diff changeset
1977 if(s->umvplus)
b76ab3c968ab AIC/MQ encoding fix
michael
parents: 1663
diff changeset
1978 s->fcode_tab= umv_fcode_tab;
b76ab3c968ab AIC/MQ encoding fix
michael
parents: 1663
diff changeset
1979 if(s->modified_quant){
b76ab3c968ab AIC/MQ encoding fix
michael
parents: 1663
diff changeset
1980 s->min_qcoeff= -2047;
b76ab3c968ab AIC/MQ encoding fix
michael
parents: 1663
diff changeset
1981 s->max_qcoeff= 2047;
b76ab3c968ab AIC/MQ encoding fix
michael
parents: 1663
diff changeset
1982 }else{
b76ab3c968ab AIC/MQ encoding fix
michael
parents: 1663
diff changeset
1983 s->min_qcoeff= -127;
b76ab3c968ab AIC/MQ encoding fix
michael
parents: 1663
diff changeset
1984 s->max_qcoeff= 127;
b76ab3c968ab AIC/MQ encoding fix
michael
parents: 1663
diff changeset
1985 }
344
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
1986 break;
498
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
1987 //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
1988 case CODEC_ID_FLV1:
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
1989 if (s->h263_flv > 1) {
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
1990 s->min_qcoeff= -1023;
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
1991 s->max_qcoeff= 1023;
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
1992 } else {
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
1993 s->min_qcoeff= -127;
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
1994 s->max_qcoeff= 127;
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
1995 }
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
1996 s->y_dc_scale_table=
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
1997 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
1998 break;
344
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
1999 default: //nothing needed default table allready set in mpegvideo.c
1089
7e79a58954b1 h263(+) clenaup & bugfixes
michaelni
parents: 1070
diff changeset
2000 s->min_qcoeff= -127;
344
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
2001 s->max_qcoeff= 127;
498
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
2002 s->y_dc_scale_table=
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
2003 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
344
9f6071a87e17 fixed msmpeg4 infinite loop if buggy stream
michaelni
parents: 341
diff changeset
2004 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2005 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
2006
1034
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
2007 /**
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
2008 * encodes a 8x8 block.
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
2009 * @param block the 8x8 block
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
2010 * @param n block index (0-3 are luma, 4-5 are chroma)
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
2011 */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2012 static void h263_encode_block(MpegEncContext * s, DCTELEM * block, int n)
986e461dc072 Initial revision
glantau
parents:
diff changeset
2013 {
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
2014 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
2015 RLTable *rl;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2016
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
2017 rl = &rl_inter;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
2018 if (s->mb_intra && !s->h263_aic) {
231
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
2019 /* DC coef */
1089
7e79a58954b1 h263(+) clenaup & bugfixes
michaelni
parents: 1070
diff changeset
2020 level = block[0];
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2021 /* 255 cannot be represented, so we clamp */
986e461dc072 Initial revision
glantau
parents:
diff changeset
2022 if (level > 254) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
2023 level = 254;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2024 block[0] = 254;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2025 }
231
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
2026 /* 0 cannot be represented also */
1089
7e79a58954b1 h263(+) clenaup & bugfixes
michaelni
parents: 1070
diff changeset
2027 else if (level < 1) {
231
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
2028 level = 1;
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
2029 block[0] = 1;
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
2030 }
1090
michaelni
parents: 1089
diff changeset
2031 if (level == 128) //FIXME check rv10
1089
7e79a58954b1 h263(+) clenaup & bugfixes
michaelni
parents: 1070
diff changeset
2032 put_bits(&s->pb, 8, 0xff);
7e79a58954b1 h263(+) clenaup & bugfixes
michaelni
parents: 1070
diff changeset
2033 else
7e79a58954b1 h263(+) clenaup & bugfixes
michaelni
parents: 1070
diff changeset
2034 put_bits(&s->pb, 8, level & 0xff);
7e79a58954b1 h263(+) clenaup & bugfixes
michaelni
parents: 1070
diff changeset
2035 i = 1;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2036 } else {
1089
7e79a58954b1 h263(+) clenaup & bugfixes
michaelni
parents: 1070
diff changeset
2037 i = 0;
7e79a58954b1 h263(+) clenaup & bugfixes
michaelni
parents: 1070
diff changeset
2038 if (s->h263_aic && s->mb_intra)
7e79a58954b1 h263(+) clenaup & bugfixes
michaelni
parents: 1070
diff changeset
2039 rl = &rl_intra_aic;
1637
7799582dc9b8 h263 alternative inter vlc support
michael
parents: 1633
diff changeset
2040
7799582dc9b8 h263 alternative inter vlc support
michael
parents: 1633
diff changeset
2041 if(s->alt_inter_vlc && !s->mb_intra){
7799582dc9b8 h263 alternative inter vlc support
michael
parents: 1633
diff changeset
2042 int aic_vlc_bits=0;
7799582dc9b8 h263 alternative inter vlc support
michael
parents: 1633
diff changeset
2043 int inter_vlc_bits=0;
7799582dc9b8 h263 alternative inter vlc support
michael
parents: 1633
diff changeset
2044 int wrong_pos=-1;
7799582dc9b8 h263 alternative inter vlc support
michael
parents: 1633
diff changeset
2045 int aic_code;
7799582dc9b8 h263 alternative inter vlc support
michael
parents: 1633
diff changeset
2046
7799582dc9b8 h263 alternative inter vlc support
michael
parents: 1633
diff changeset
2047 last_index = s->block_last_index[n];
7799582dc9b8 h263 alternative inter vlc support
michael
parents: 1633
diff changeset
2048 last_non_zero = i - 1;
7799582dc9b8 h263 alternative inter vlc support
michael
parents: 1633
diff changeset
2049 for (; i <= last_index; i++) {
7799582dc9b8 h263 alternative inter vlc support
michael
parents: 1633
diff changeset
2050 j = s->intra_scantable.permutated[i];
7799582dc9b8 h263 alternative inter vlc support
michael
parents: 1633
diff changeset
2051 level = block[j];
7799582dc9b8 h263 alternative inter vlc support
michael
parents: 1633
diff changeset
2052 if (level) {
7799582dc9b8 h263 alternative inter vlc support
michael
parents: 1633
diff changeset
2053 run = i - last_non_zero - 1;
7799582dc9b8 h263 alternative inter vlc support
michael
parents: 1633
diff changeset
2054 last = (i == last_index);
1663
4ac3573977e6 alternative inter vlc encoding fix
michael
parents: 1661
diff changeset
2055
4ac3573977e6 alternative inter vlc encoding fix
michael
parents: 1661
diff changeset
2056 if(level<0) level= -level;
1637
7799582dc9b8 h263 alternative inter vlc support
michael
parents: 1633
diff changeset
2057
7799582dc9b8 h263 alternative inter vlc support
michael
parents: 1633
diff changeset
2058 code = get_rl_index(rl, last, run, level);
7799582dc9b8 h263 alternative inter vlc support
michael
parents: 1633
diff changeset
2059 aic_code = get_rl_index(&rl_intra_aic, last, run, level);
7799582dc9b8 h263 alternative inter vlc support
michael
parents: 1633
diff changeset
2060 inter_vlc_bits += rl->table_vlc[code][1]+1;
7799582dc9b8 h263 alternative inter vlc support
michael
parents: 1633
diff changeset
2061 aic_vlc_bits += rl_intra_aic.table_vlc[aic_code][1]+1;
7799582dc9b8 h263 alternative inter vlc support
michael
parents: 1633
diff changeset
2062
7799582dc9b8 h263 alternative inter vlc support
michael
parents: 1633
diff changeset
2063 if (code == rl->n) {
1663
4ac3573977e6 alternative inter vlc encoding fix
michael
parents: 1661
diff changeset
2064 inter_vlc_bits += 1+6+8-1;
1637
7799582dc9b8 h263 alternative inter vlc support
michael
parents: 1633
diff changeset
2065 }
7799582dc9b8 h263 alternative inter vlc support
michael
parents: 1633
diff changeset
2066 if (aic_code == rl_intra_aic.n) {
1663
4ac3573977e6 alternative inter vlc encoding fix
michael
parents: 1661
diff changeset
2067 aic_vlc_bits += 1+6+8-1;
1637
7799582dc9b8 h263 alternative inter vlc support
michael
parents: 1633
diff changeset
2068 wrong_pos += run + 1;
7799582dc9b8 h263 alternative inter vlc support
michael
parents: 1633
diff changeset
2069 }else
7799582dc9b8 h263 alternative inter vlc support
michael
parents: 1633
diff changeset
2070 wrong_pos += wrong_run[aic_code];
7799582dc9b8 h263 alternative inter vlc support
michael
parents: 1633
diff changeset
2071 last_non_zero = i;
7799582dc9b8 h263 alternative inter vlc support
michael
parents: 1633
diff changeset
2072 }
7799582dc9b8 h263 alternative inter vlc support
michael
parents: 1633
diff changeset
2073 }
7799582dc9b8 h263 alternative inter vlc support
michael
parents: 1633
diff changeset
2074 i = 0;
7799582dc9b8 h263 alternative inter vlc support
michael
parents: 1633
diff changeset
2075 if(aic_vlc_bits < inter_vlc_bits && wrong_pos > 63)
7799582dc9b8 h263 alternative inter vlc support
michael
parents: 1633
diff changeset
2076 rl = &rl_intra_aic;
7799582dc9b8 h263 alternative inter vlc support
michael
parents: 1633
diff changeset
2077 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2078 }
350
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
2079
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2080 /* AC coefs */
986e461dc072 Initial revision
glantau
parents:
diff changeset
2081 last_index = s->block_last_index[n];
986e461dc072 Initial revision
glantau
parents:
diff changeset
2082 last_non_zero = i - 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2083 for (; i <= last_index; i++) {
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
2084 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
2085 level = block[j];
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
2086 if (level) {
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
2087 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
2088 last = (i == last_index);
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
2089 sign = 0;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
2090 slevel = level;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
2091 if (level < 0) {
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
2092 sign = 1;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
2093 level = -level;
6ebbecc10063 - Advanced Intra Coding (AIC) support for H.263+ encoder, just DC by now.
pulento
parents: 346
diff changeset
2094 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2095 code = get_rl_index(rl, last, run, level);
986e461dc072 Initial revision
glantau
parents:
diff changeset
2096 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
986e461dc072 Initial revision
glantau
parents:
diff changeset
2097 if (code == rl->n) {
1354
1f89adb69349 flv cleanup / simplify
michaelni
parents: 1353
diff changeset
2098 if(s->h263_flv <= 1){
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2099 put_bits(&s->pb, 1, last);
986e461dc072 Initial revision
glantau
parents:
diff changeset
2100 put_bits(&s->pb, 6, run);
1089
7e79a58954b1 h263(+) clenaup & bugfixes
michaelni
parents: 1070
diff changeset
2101
7e79a58954b1 h263(+) clenaup & bugfixes
michaelni
parents: 1070
diff changeset
2102 assert(slevel != 0);
7e79a58954b1 h263(+) clenaup & bugfixes
michaelni
parents: 1070
diff changeset
2103
7e79a58954b1 h263(+) clenaup & bugfixes
michaelni
parents: 1070
diff changeset
2104 if(slevel < 128 && slevel > -128)
7e79a58954b1 h263(+) clenaup & bugfixes
michaelni
parents: 1070
diff changeset
2105 put_bits(&s->pb, 8, slevel & 0xff);
7e79a58954b1 h263(+) clenaup & bugfixes
michaelni
parents: 1070
diff changeset
2106 else{
7e79a58954b1 h263(+) clenaup & bugfixes
michaelni
parents: 1070
diff changeset
2107 put_bits(&s->pb, 8, 128);
7e79a58954b1 h263(+) clenaup & bugfixes
michaelni
parents: 1070
diff changeset
2108 put_bits(&s->pb, 5, slevel & 0x1f);
7e79a58954b1 h263(+) clenaup & bugfixes
michaelni
parents: 1070
diff changeset
2109 put_bits(&s->pb, 6, (slevel>>5)&0x3f);
7e79a58954b1 h263(+) clenaup & bugfixes
michaelni
parents: 1070
diff changeset
2110 }
1354
1f89adb69349 flv cleanup / simplify
michaelni
parents: 1353
diff changeset
2111 }else{
1f89adb69349 flv cleanup / simplify
michaelni
parents: 1353
diff changeset
2112 if(slevel < 64 && slevel > -64) {
1f89adb69349 flv cleanup / simplify
michaelni
parents: 1353
diff changeset
2113 /* 7-bit level */
1f89adb69349 flv cleanup / simplify
michaelni
parents: 1353
diff changeset
2114 put_bits(&s->pb, 1, 0);
1f89adb69349 flv cleanup / simplify
michaelni
parents: 1353
diff changeset
2115 put_bits(&s->pb, 1, last);
1f89adb69349 flv cleanup / simplify
michaelni
parents: 1353
diff changeset
2116 put_bits(&s->pb, 6, run);
1f89adb69349 flv cleanup / simplify
michaelni
parents: 1353
diff changeset
2117
1f89adb69349 flv cleanup / simplify
michaelni
parents: 1353
diff changeset
2118 put_bits(&s->pb, 7, slevel & 0x7f);
1f89adb69349 flv cleanup / simplify
michaelni
parents: 1353
diff changeset
2119 } else {
1f89adb69349 flv cleanup / simplify
michaelni
parents: 1353
diff changeset
2120 /* 11-bit level */
1f89adb69349 flv cleanup / simplify
michaelni
parents: 1353
diff changeset
2121 put_bits(&s->pb, 1, 1);
1f89adb69349 flv cleanup / simplify
michaelni
parents: 1353
diff changeset
2122 put_bits(&s->pb, 1, last);
1f89adb69349 flv cleanup / simplify
michaelni
parents: 1353
diff changeset
2123 put_bits(&s->pb, 6, run);
1f89adb69349 flv cleanup / simplify
michaelni
parents: 1353
diff changeset
2124
1f89adb69349 flv cleanup / simplify
michaelni
parents: 1353
diff changeset
2125 put_bits(&s->pb, 11, slevel & 0x7ff);
1f89adb69349 flv cleanup / simplify
michaelni
parents: 1353
diff changeset
2126 }
1f89adb69349 flv cleanup / simplify
michaelni
parents: 1353
diff changeset
2127 }
1353
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
2128 } else {
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
2129 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
2130 }
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
2131 last_non_zero = i;
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
2132 }
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
2133 }
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
2134 }
815
78accc54493b put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents: 770
diff changeset
2135 #endif
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2136
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
2137 #ifdef CONFIG_ENCODERS
6da5ae9ee199 more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents: 1068
diff changeset
2138
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2139 /***************************************************/
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2140 /**
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2141 * add mpeg4 stuffing bits (01...1)
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2142 */
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2143 void ff_mpeg4_stuffing(PutBitContext * pbc)
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2144 {
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2145 int length;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2146 put_bits(pbc, 1, 0);
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2147 length= (-get_bit_count(pbc))&7;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2148 if(length) put_bits(pbc, length, (1<<length)-1);
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2149 }
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2150
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
2151 /* must be called before writing the header */
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
2152 void ff_set_mpeg4_time(MpegEncContext * s, int picture_number){
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
2153 int time_div, time_mod;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
2154
1586
3d1d0490e5a6 pts fix and related fixes
michael
parents: 1584
diff changeset
2155 if(s->current_picture_ptr->pts)
3d1d0490e5a6 pts fix and related fixes
michael
parents: 1584
diff changeset
2156 s->time= (s->current_picture_ptr->pts*s->time_increment_resolution + 500*1000)/(1000*1000);
654
850098147a3c export pts from stream if available
michaelni
parents: 648
diff changeset
2157 else
1126
77ccf7fe3bd0 per context frame_rate_base, this should finally fix frame_rate related av sync issues
michaelni
parents: 1118
diff changeset
2158 s->time= av_rescale(picture_number*(int64_t)s->avctx->frame_rate_base, s->time_increment_resolution, s->avctx->frame_rate);
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
2159 time_div= s->time/s->time_increment_resolution;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
2160 time_mod= s->time%s->time_increment_resolution;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
2161
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
2162 if(s->pict_type==B_TYPE){
664
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
2163 s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
2164 }else{
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
2165 s->last_time_base= s->time_base;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
2166 s->time_base= time_div;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
2167 s->pp_time= s->time - s->last_non_b_time;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
2168 s->last_non_b_time= s->time;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
2169 }
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
2170 }
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
2171
942
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
2172 static void mpeg4_encode_gop_header(MpegEncContext * s){
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
2173 int hours, minutes, seconds;
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
2174
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
2175 put_bits(&s->pb, 16, 0);
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
2176 put_bits(&s->pb, 16, GOP_STARTCODE);
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
2177
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
2178 seconds= s->time/s->time_increment_resolution;
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
2179 minutes= seconds/60; seconds %= 60;
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
2180 hours= minutes/60; minutes %= 60;
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
2181 hours%=24;
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
2182
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
2183 put_bits(&s->pb, 5, hours);
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
2184 put_bits(&s->pb, 6, minutes);
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
2185 put_bits(&s->pb, 1, 1);
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
2186 put_bits(&s->pb, 6, seconds);
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
2187
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
2188 put_bits(&s->pb, 1, 0); //closed gov == NO
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
2189 put_bits(&s->pb, 1, 0); //broken link == NO
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
2190
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
2191 ff_mpeg4_stuffing(&s->pb);
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
2192 }
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
2193
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
2194 static void mpeg4_encode_visual_object_header(MpegEncContext * s){
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
2195 int profile_and_level_indication;
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
2196 int vo_ver_id;
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
2197
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
2198 if(s->max_b_frames || s->quarter_sample){
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
2199 profile_and_level_indication= 0xF1; // adv simple level 1
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
2200 vo_ver_id= 5;
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
2201 }else{
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
2202 profile_and_level_indication= 0x01; // simple level 1
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
2203 vo_ver_id= 1;
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
2204 }
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
2205 //FIXME levels
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
2206
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
2207 put_bits(&s->pb, 16, 0);
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
2208 put_bits(&s->pb, 16, VOS_STARTCODE);
1350
e7c8051e1849 the reference sw doesnt like some legal headers ...
michaelni
parents: 1346
diff changeset
2209
942
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
2210 put_bits(&s->pb, 8, profile_and_level_indication);
1350
e7c8051e1849 the reference sw doesnt like some legal headers ...
michaelni
parents: 1346
diff changeset
2211
942
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
2212 put_bits(&s->pb, 16, 0);
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
2213 put_bits(&s->pb, 16, VISUAL_OBJ_STARTCODE);
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
2214
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
2215 put_bits(&s->pb, 1, 1);
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
2216 put_bits(&s->pb, 4, vo_ver_id);
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
2217 put_bits(&s->pb, 3, 1); //priority
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
2218
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
2219 put_bits(&s->pb, 4, 1); //visual obj type== video obj
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
2220
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
2221 put_bits(&s->pb, 1, 0); //video signal type == no clue //FIXME
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
2222
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
2223 ff_mpeg4_stuffing(&s->pb);
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
2224 }
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
2225
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
2226 static void mpeg4_encode_vol_header(MpegEncContext * s, int vo_number, int vol_number)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2227 {
942
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
2228 int vo_ver_id;
336
c56b45669214 export delay info
michaelni
parents: 335
diff changeset
2229
942
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
2230 if(s->max_b_frames || s->quarter_sample){
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
2231 vo_ver_id= 5;
923
3b5d9ecedc73 correct mpeg4 vo type
michaelni
parents: 921
diff changeset
2232 s->vo_type= ADV_SIMPLE_VO_TYPE;
3b5d9ecedc73 correct mpeg4 vo type
michaelni
parents: 921
diff changeset
2233 }else{
942
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
2234 vo_ver_id= 1;
923
3b5d9ecedc73 correct mpeg4 vo type
michaelni
parents: 921
diff changeset
2235 s->vo_type= SIMPLE_VO_TYPE;
3b5d9ecedc73 correct mpeg4 vo type
michaelni
parents: 921
diff changeset
2236 }
336
c56b45669214 export delay info
michaelni
parents: 335
diff changeset
2237
263
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
2238 put_bits(&s->pb, 16, 0);
942
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
2239 put_bits(&s->pb, 16, 0x100 + vo_number); /* video obj */
263
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
2240 put_bits(&s->pb, 16, 0);
942
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
2241 put_bits(&s->pb, 16, 0x120 + vol_number); /* video obj layer */
263
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
2242
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
2243 put_bits(&s->pb, 1, 0); /* random access vol */
336
c56b45669214 export delay info
michaelni
parents: 335
diff changeset
2244 put_bits(&s->pb, 8, s->vo_type); /* video obj type indication */
263
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
2245 put_bits(&s->pb, 1, 1); /* is obj layer id= yes */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
2246 put_bits(&s->pb, 4, vo_ver_id); /* is obj layer ver id */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
2247 put_bits(&s->pb, 3, 1); /* is obj layer priority */
880
1c32039e7215 aspect ratio cleanup
michaelni
parents: 853
diff changeset
2248
1548
dd544554ed42 AVRational
michael
parents: 1542
diff changeset
2249 aspect_to_info(s, s->avctx->sample_aspect_ratio);
880
1c32039e7215 aspect ratio cleanup
michaelni
parents: 853
diff changeset
2250
1c32039e7215 aspect ratio cleanup
michaelni
parents: 853
diff changeset
2251 put_bits(&s->pb, 4, s->aspect_ratio_info);/* aspect ratio info */
1548
dd544554ed42 AVRational
michael
parents: 1542
diff changeset
2252 if (s->aspect_ratio_info == FF_ASPECT_EXTENDED){
dd544554ed42 AVRational
michael
parents: 1542
diff changeset
2253 put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.num);
dd544554ed42 AVRational
michael
parents: 1542
diff changeset
2254 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
2255 }
336
c56b45669214 export delay info
michaelni
parents: 335
diff changeset
2256
c56b45669214 export delay info
michaelni
parents: 335
diff changeset
2257 if(s->low_delay){
c56b45669214 export delay info
michaelni
parents: 335
diff changeset
2258 put_bits(&s->pb, 1, 1); /* vol control parameters= yes */
341
bf26081c373c avcodec_flush_buffers()
michaelni
parents: 339
diff changeset
2259 put_bits(&s->pb, 2, 1); /* chroma format YUV 420/YV12 */
336
c56b45669214 export delay info
michaelni
parents: 335
diff changeset
2260 put_bits(&s->pb, 1, s->low_delay);
c56b45669214 export delay info
michaelni
parents: 335
diff changeset
2261 put_bits(&s->pb, 1, 0); /* vbv parameters= no */
c56b45669214 export delay info
michaelni
parents: 335
diff changeset
2262 }else{
c56b45669214 export delay info
michaelni
parents: 335
diff changeset
2263 put_bits(&s->pb, 1, 0); /* vol control parameters= no */
c56b45669214 export delay info
michaelni
parents: 335
diff changeset
2264 }
c56b45669214 export delay info
michaelni
parents: 335
diff changeset
2265
263
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
2266 put_bits(&s->pb, 2, RECT_SHAPE); /* vol shape= rectangle */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
2267 put_bits(&s->pb, 1, 1); /* marker bit */
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
2268
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
2269 put_bits(&s->pb, 16, s->time_increment_resolution);
263
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
2270 if (s->time_increment_bits < 1)
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
2271 s->time_increment_bits = 1;
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
2272 put_bits(&s->pb, 1, 1); /* marker bit */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
2273 put_bits(&s->pb, 1, 0); /* fixed vop rate=no */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
2274 put_bits(&s->pb, 1, 1); /* marker bit */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
2275 put_bits(&s->pb, 13, s->width); /* vol width */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
2276 put_bits(&s->pb, 1, 1); /* marker bit */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
2277 put_bits(&s->pb, 13, s->height); /* vol height */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
2278 put_bits(&s->pb, 1, 1); /* marker bit */
697
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2279 put_bits(&s->pb, 1, s->progressive_sequence ? 0 : 1);
263
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
2280 put_bits(&s->pb, 1, 1); /* obmc disable */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
2281 if (vo_ver_id == 1) {
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
2282 put_bits(&s->pb, 1, s->vol_sprite_usage=0); /* sprite enable */
942
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
2283 }else{
263
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
2284 put_bits(&s->pb, 2, s->vol_sprite_usage=0); /* sprite enable */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
2285 }
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2286
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2287 s->quant_precision=5;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2288 put_bits(&s->pb, 1, 0); /* not 8 bit == false */
599
b1a191202f96 mpeg4 mpeg quantizer encoding
michaelni
parents: 598
diff changeset
2289 put_bits(&s->pb, 1, s->mpeg_quant); /* quant type= (0=h263 style)*/
1411
c2e63cb94d06 custom quant matrix encoding support
michaelni
parents: 1396
diff changeset
2290
c2e63cb94d06 custom quant matrix encoding support
michaelni
parents: 1396
diff changeset
2291 if(s->mpeg_quant){
c2e63cb94d06 custom quant matrix encoding support
michaelni
parents: 1396
diff changeset
2292 ff_write_quant_matrix(&s->pb, s->avctx->intra_matrix);
c2e63cb94d06 custom quant matrix encoding support
michaelni
parents: 1396
diff changeset
2293 ff_write_quant_matrix(&s->pb, s->avctx->inter_matrix);
c2e63cb94d06 custom quant matrix encoding support
michaelni
parents: 1396
diff changeset
2294 }
599
b1a191202f96 mpeg4 mpeg quantizer encoding
michaelni
parents: 598
diff changeset
2295
263
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
2296 if (vo_ver_id != 1)
936
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2297 put_bits(&s->pb, 1, s->quarter_sample);
263
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
2298 put_bits(&s->pb, 1, 1); /* complexity estimation disable */
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2299 s->resync_marker= s->rtp_mode;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2300 put_bits(&s->pb, 1, s->resync_marker ? 0 : 1);/* resync marker disable */
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2301 put_bits(&s->pb, 1, s->data_partitioning ? 1 : 0);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2302 if(s->data_partitioning){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2303 put_bits(&s->pb, 1, 0); /* no rvlc */
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2304 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2305
263
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
2306 if (vo_ver_id != 1){
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
2307 put_bits(&s->pb, 1, 0); /* newpred */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
2308 put_bits(&s->pb, 1, 0); /* reduced res vop */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
2309 }
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
2310 put_bits(&s->pb, 1, 0); /* scalability */
676
c3bdb00a98a9 dont store version for bit-exact tests
michaelni
parents: 674
diff changeset
2311
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2312 ff_mpeg4_stuffing(&s->pb);
676
c3bdb00a98a9 dont store version for bit-exact tests
michaelni
parents: 674
diff changeset
2313
c3bdb00a98a9 dont store version for bit-exact tests
michaelni
parents: 674
diff changeset
2314 /* user data */
1092
f59c3f66363b MpegEncContext.(i)dct_* -> DspContext.(i)dct_*
michaelni
parents: 1090
diff changeset
2315 if(!(s->flags & CODEC_FLAG_BITEXACT)){
676
c3bdb00a98a9 dont store version for bit-exact tests
michaelni
parents: 674
diff changeset
2316 put_bits(&s->pb, 16, 0);
c3bdb00a98a9 dont store version for bit-exact tests
michaelni
parents: 674
diff changeset
2317 put_bits(&s->pb, 16, 0x1B2); /* user_data */
1118
8248e652d64e simplified
al3x
parents: 1106
diff changeset
2318 put_string(&s->pb, LIBAVCODEC_IDENT);
676
c3bdb00a98a9 dont store version for bit-exact tests
michaelni
parents: 674
diff changeset
2319 ff_mpeg4_stuffing(&s->pb);
c3bdb00a98a9 dont store version for bit-exact tests
michaelni
parents: 674
diff changeset
2320 }
263
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
2321 }
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
2322
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
2323 /* write mpeg4 VOP header */
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
2324 void mpeg4_encode_picture_header(MpegEncContext * s, int picture_number)
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
2325 {
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
2326 int time_incr;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
2327 int time_div, time_mod;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
2328
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2329 if(s->pict_type==I_TYPE){
953
9eb066d6e0db mpeg4 header encoding bugfix
michaelni
parents: 945
diff changeset
2330 if(!(s->flags&CODEC_FLAG_GLOBAL_HEADER)){
1350
e7c8051e1849 the reference sw doesnt like some legal headers ...
michaelni
parents: 1346
diff changeset
2331 if(s->strict_std_compliance < 2) //HACK, the reference sw is buggy
e7c8051e1849 the reference sw doesnt like some legal headers ...
michaelni
parents: 1346
diff changeset
2332 mpeg4_encode_visual_object_header(s);
e7c8051e1849 the reference sw doesnt like some legal headers ...
michaelni
parents: 1346
diff changeset
2333 if(s->strict_std_compliance < 2 || picture_number==0) //HACK, the reference sw is buggy
e7c8051e1849 the reference sw doesnt like some legal headers ...
michaelni
parents: 1346
diff changeset
2334 mpeg4_encode_vol_header(s, 0, 0);
942
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
2335 }
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
2336 mpeg4_encode_gop_header(s);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2337 }
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
2338
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2339 s->partitioned_frame= s->data_partitioning && s->pict_type!=B_TYPE;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2340
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
2341 //printf("num:%d rate:%d base:%d\n", s->picture_number, s->frame_rate, FRAME_RATE_BASE);
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
2342
234
5fc0c3af3fe4 alternative bitstream writer (disabled by default, uncomment #define ALT_BISTREAM_WRITER in common.h if u want to try it)
michaelni
parents: 231
diff changeset
2343 put_bits(&s->pb, 16, 0); /* vop header */
942
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
2344 put_bits(&s->pb, 16, VOP_STARTCODE); /* vop header */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2345 put_bits(&s->pb, 2, s->pict_type - 1); /* pict type: I = 0 , P = 1 */
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
2346
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
2347 time_div= s->time/s->time_increment_resolution;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 325
diff changeset
2348 time_mod= s->time%s->time_increment_resolution;
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
2349 time_incr= time_div - s->last_time_base;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
2350 while(time_incr--)
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
2351 put_bits(&s->pb, 1, 1);
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
2352
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2353 put_bits(&s->pb, 1, 0);
986e461dc072 Initial revision
glantau
parents:
diff changeset
2354
986e461dc072 Initial revision
glantau
parents:
diff changeset
2355 put_bits(&s->pb, 1, 1); /* marker */
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
2356 put_bits(&s->pb, s->time_increment_bits, time_mod); /* time increment */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2357 put_bits(&s->pb, 1, 1); /* marker */
986e461dc072 Initial revision
glantau
parents:
diff changeset
2358 put_bits(&s->pb, 1, 1); /* vop coded */
263
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
2359 if ( s->pict_type == P_TYPE
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
2360 || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE)) {
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2361 put_bits(&s->pb, 1, s->no_rounding); /* rounding type */
986e461dc072 Initial revision
glantau
parents:
diff changeset
2362 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
2363 put_bits(&s->pb, 3, 0); /* intra dc VLC threshold */
697
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2364 if(!s->progressive_sequence){
1659
3075fc11a974 AVFrame.interlaced_frame fixes
michael
parents: 1656
diff changeset
2365 put_bits(&s->pb, 1, s->current_picture_ptr->top_field_first);
697
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2366 put_bits(&s->pb, 1, s->alternate_scan);
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
2367 }
263
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
2368 //FIXME sprite stuff
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2369
986e461dc072 Initial revision
glantau
parents:
diff changeset
2370 put_bits(&s->pb, 5, s->qscale);
986e461dc072 Initial revision
glantau
parents:
diff changeset
2371
986e461dc072 Initial revision
glantau
parents:
diff changeset
2372 if (s->pict_type != I_TYPE)
986e461dc072 Initial revision
glantau
parents:
diff changeset
2373 put_bits(&s->pb, 3, s->f_code); /* fcode_for */
263
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
2374 if (s->pict_type == B_TYPE)
126edd7d2803 generate even more complete mpeg4 headers
michaelni
parents: 262
diff changeset
2375 put_bits(&s->pb, 3, s->b_code); /* fcode_back */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2376 // printf("****frame %d\n", picture_number);
498
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
2377
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
2378 s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table; //FIXME add short header support
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
2379 s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2380 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
2381
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
2382 #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
2383
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2384 /**
1652
834922115010 cleanup
michael
parents: 1649
diff changeset
2385 * set qscale and update qscale dependant variables.
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2386 */
1652
834922115010 cleanup
michael
parents: 1649
diff changeset
2387 void ff_set_qscale(MpegEncContext * s, int qscale)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2388 {
1652
834922115010 cleanup
michael
parents: 1649
diff changeset
2389 if (qscale < 1)
834922115010 cleanup
michael
parents: 1649
diff changeset
2390 qscale = 1;
834922115010 cleanup
michael
parents: 1649
diff changeset
2391 else if (qscale > 31)
834922115010 cleanup
michael
parents: 1649
diff changeset
2392 qscale = 31;
1644
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
2393
1652
834922115010 cleanup
michael
parents: 1649
diff changeset
2394 s->qscale = qscale;
834922115010 cleanup
michael
parents: 1649
diff changeset
2395 s->chroma_qscale= s->chroma_qscale_table[qscale];
834922115010 cleanup
michael
parents: 1649
diff changeset
2396
834922115010 cleanup
michael
parents: 1649
diff changeset
2397 s->y_dc_scale= s->y_dc_scale_table[ qscale ];
1644
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
2398 s->c_dc_scale= s->c_dc_scale_table[ s->chroma_qscale ];
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2399 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
2400
1034
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
2401 /**
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
2402 * predicts the dc.
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
2403 * @param n block index (0-3 are luma, 4-5 are chroma)
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
2404 * @param dc_val_ptr a pointer to the dc_val entry for the current MB will be stored here
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
2405 * @param dir_ptr pointer to an integer where the prediction direction will be stored
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
2406 * @return the quantized predicted dc
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
2407 */
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
2408 static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, uint16_t **dc_val_ptr, int *dir_ptr)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2409 {
266
252444e5259b optimization
michaelni
parents: 265
diff changeset
2410 int a, b, c, wrap, pred, scale;
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
2411 uint16_t *dc_val;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2412
986e461dc072 Initial revision
glantau
parents:
diff changeset
2413 /* find prediction */
986e461dc072 Initial revision
glantau
parents:
diff changeset
2414 if (n < 4) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
2415 scale = s->y_dc_scale;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2416 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
2417 scale = s->c_dc_scale;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2418 }
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
2419 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
2420 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
2421
266
252444e5259b optimization
michaelni
parents: 265
diff changeset
2422 wrap= s->block_wrap[n];
252444e5259b optimization
michaelni
parents: 265
diff changeset
2423 dc_val = s->dc_val[0] + s->block_index[n];
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2424
986e461dc072 Initial revision
glantau
parents:
diff changeset
2425 /* B C
986e461dc072 Initial revision
glantau
parents:
diff changeset
2426 * A X
986e461dc072 Initial revision
glantau
parents:
diff changeset
2427 */
266
252444e5259b optimization
michaelni
parents: 265
diff changeset
2428 a = dc_val[ - 1];
252444e5259b optimization
michaelni
parents: 265
diff changeset
2429 b = dc_val[ - 1 - wrap];
252444e5259b optimization
michaelni
parents: 265
diff changeset
2430 c = dc_val[ - wrap];
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2431
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2432 /* outside slice handling (we cant do that by memset as we need the dc for error resilience) */
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2433 if(s->first_slice_line && n!=3){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2434 if(n!=2) b=c= 1024;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2435 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
2436 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2437 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
2438 if(n==0 || n==4 || n==5)
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2439 b=1024;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2440 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2441
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2442 if (abs(a - b) < abs(b - c)) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
2443 pred = c;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2444 *dir_ptr = 1; /* top */
986e461dc072 Initial revision
glantau
parents:
diff changeset
2445 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
2446 pred = a;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2447 *dir_ptr = 0; /* left */
986e461dc072 Initial revision
glantau
parents:
diff changeset
2448 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
2449 /* 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
2450 pred = FASTDIV((pred + (scale >> 1)), scale);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2451
986e461dc072 Initial revision
glantau
parents:
diff changeset
2452 /* prepare address for prediction update */
266
252444e5259b optimization
michaelni
parents: 265
diff changeset
2453 *dc_val_ptr = &dc_val[0];
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2454
986e461dc072 Initial revision
glantau
parents:
diff changeset
2455 return pred;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2456 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
2457
1034
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
2458 /**
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
2459 * predicts the ac.
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
2460 * @param n block index (0-3 are luma, 4-5 are chroma)
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
2461 * @param dir the ac prediction direction
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
2462 */
1008
fb6cbb8a04a3 fixing DCTELEM != short
michaelni
parents: 999
diff changeset
2463 void mpeg4_pred_ac(MpegEncContext * s, DCTELEM *block, int n,
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2464 int dir)
986e461dc072 Initial revision
glantau
parents:
diff changeset
2465 {
266
252444e5259b optimization
michaelni
parents: 265
diff changeset
2466 int i;
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
2467 int16_t *ac_val, *ac_val1;
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
2468 int8_t * const qscale_table= s->current_picture.qscale_table;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2469
986e461dc072 Initial revision
glantau
parents:
diff changeset
2470 /* find prediction */
266
252444e5259b optimization
michaelni
parents: 265
diff changeset
2471 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2472 ac_val1 = ac_val;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2473 if (s->ac_pred) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
2474 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
2475 const int xy= s->mb_x-1 + s->mb_y*s->mb_stride;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2476 /* left prediction */
986e461dc072 Initial revision
glantau
parents:
diff changeset
2477 ac_val -= 16;
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
2478
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
2479 if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
2480 /* same qscale */
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
2481 for(i=1;i<8;i++) {
1092
f59c3f66363b MpegEncContext.(i)dct_* -> DspContext.(i)dct_*
michaelni
parents: 1090
diff changeset
2482 block[s->dsp.idct_permutation[i<<3]] += ac_val[i];
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
2483 }
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
2484 }else{
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
2485 /* different qscale, we must rescale */
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
2486 for(i=1;i<8;i++) {
1092
f59c3f66363b MpegEncContext.(i)dct_* -> DspContext.(i)dct_*
michaelni
parents: 1090
diff changeset
2487 block[s->dsp.idct_permutation[i<<3]] += ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale);
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
2488 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2489 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
2490 } 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
2491 const int xy= s->mb_x + s->mb_y*s->mb_stride - s->mb_stride;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2492 /* top prediction */
266
252444e5259b optimization
michaelni
parents: 265
diff changeset
2493 ac_val -= 16 * s->block_wrap[n];
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
2494
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
2495 if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
2496 /* same qscale */
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
2497 for(i=1;i<8;i++) {
1092
f59c3f66363b MpegEncContext.(i)dct_* -> DspContext.(i)dct_*
michaelni
parents: 1090
diff changeset
2498 block[s->dsp.idct_permutation[i]] += ac_val[i + 8];
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
2499 }
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
2500 }else{
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
2501 /* different qscale, we must rescale */
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
2502 for(i=1;i<8;i++) {
1092
f59c3f66363b MpegEncContext.(i)dct_* -> DspContext.(i)dct_*
michaelni
parents: 1090
diff changeset
2503 block[s->dsp.idct_permutation[i]] += ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale);
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
2504 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2505 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
2506 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
2507 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
2508 /* left copy */
986e461dc072 Initial revision
glantau
parents:
diff changeset
2509 for(i=1;i<8;i++)
1092
f59c3f66363b MpegEncContext.(i)dct_* -> DspContext.(i)dct_*
michaelni
parents: 1090
diff changeset
2510 ac_val1[i ] = block[s->dsp.idct_permutation[i<<3]];
591
d3f374218030 fixing mpeg4 mpeg quantizers
michaelni
parents: 582
diff changeset
2511
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2512 /* top copy */
986e461dc072 Initial revision
glantau
parents:
diff changeset
2513 for(i=1;i<8;i++)
1092
f59c3f66363b MpegEncContext.(i)dct_* -> DspContext.(i)dct_*
michaelni
parents: 1090
diff changeset
2514 ac_val1[8 + i] = block[s->dsp.idct_permutation[i ]];
591
d3f374218030 fixing mpeg4 mpeg quantizers
michaelni
parents: 582
diff changeset
2515
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2516 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
2517
1070
6da5ae9ee199 more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents: 1068
diff changeset
2518 #ifdef CONFIG_ENCODERS
6da5ae9ee199 more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents: 1068
diff changeset
2519
1034
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
2520 /**
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
2521 * encodes the dc value.
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
2522 * @param n block index (0-3 are luma, 4-5 are chroma)
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
2523 */
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2524 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
2525 {
293
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
2526 #if 1
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2527 // if(level<-255 || level>255) printf("dc overflow\n");
293
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
2528 level+=256;
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
2529 if (n < 4) {
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
2530 /* luminance */
1013
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1008
diff changeset
2531 put_bits(s, uni_DCtab_lum_len[level], uni_DCtab_lum_bits[level]);
293
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
2532 } else {
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
2533 /* chrominance */
1013
5d4c95f323d0 finetuneing thresholds/factors
michaelni
parents: 1008
diff changeset
2534 put_bits(s, uni_DCtab_chrom_len[level], uni_DCtab_chrom_bits[level]);
293
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
2535 }
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
2536 #else
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
2537 int size, v;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2538 /* find number of bits */
986e461dc072 Initial revision
glantau
parents:
diff changeset
2539 size = 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2540 v = abs(level);
986e461dc072 Initial revision
glantau
parents:
diff changeset
2541 while (v) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
2542 v >>= 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2543 size++;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2544 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
2545
986e461dc072 Initial revision
glantau
parents:
diff changeset
2546 if (n < 4) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
2547 /* luminance */
986e461dc072 Initial revision
glantau
parents:
diff changeset
2548 put_bits(&s->pb, DCtab_lum[size][1], DCtab_lum[size][0]);
986e461dc072 Initial revision
glantau
parents:
diff changeset
2549 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
2550 /* chrominance */
986e461dc072 Initial revision
glantau
parents:
diff changeset
2551 put_bits(&s->pb, DCtab_chrom[size][1], DCtab_chrom[size][0]);
986e461dc072 Initial revision
glantau
parents:
diff changeset
2552 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
2553
986e461dc072 Initial revision
glantau
parents:
diff changeset
2554 /* encode remaining bits */
986e461dc072 Initial revision
glantau
parents:
diff changeset
2555 if (size > 0) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
2556 if (level < 0)
986e461dc072 Initial revision
glantau
parents:
diff changeset
2557 level = (-level) ^ ((1 << size) - 1);
986e461dc072 Initial revision
glantau
parents:
diff changeset
2558 put_bits(&s->pb, size, level);
986e461dc072 Initial revision
glantau
parents:
diff changeset
2559 if (size > 8)
986e461dc072 Initial revision
glantau
parents:
diff changeset
2560 put_bits(&s->pb, 1, 1);
986e461dc072 Initial revision
glantau
parents:
diff changeset
2561 }
293
6eaf5da091fa optimizing mpeg4_encode_dc
michaelni
parents: 292
diff changeset
2562 #endif
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2563 }
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
2564
1034
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
2565 /**
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
2566 * encodes a 8x8 block
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
2567 * @param n block index (0-3 are luma, 4-5 are chroma)
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
2568 */
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
2569 static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n, int intra_dc,
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
2570 uint8_t *scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2571 {
751
cbe316f082bc warning fixes
michaelni
parents: 747
diff changeset
2572 int i, last_non_zero;
cbe316f082bc warning fixes
michaelni
parents: 747
diff changeset
2573 #if 0 //variables for the outcommented version
cbe316f082bc warning fixes
michaelni
parents: 747
diff changeset
2574 int code, sign, last;
cbe316f082bc warning fixes
michaelni
parents: 747
diff changeset
2575 #endif
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2576 const RLTable *rl;
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
2577 uint32_t *bits_tab;
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
2578 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
2579 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
2580
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
2581 if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2582 /* mpeg4 based DC predictor */
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2583 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
2584 if(last_index<1) return;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2585 i = 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2586 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
2587 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
2588 len_tab = uni_mpeg4_intra_rl_len;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2589 } 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
2590 if(last_index<0) return;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2591 i = 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2592 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
2593 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
2594 len_tab = uni_mpeg4_inter_rl_len;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2595 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
2596
986e461dc072 Initial revision
glantau
parents:
diff changeset
2597 /* AC coefs */
986e461dc072 Initial revision
glantau
parents:
diff changeset
2598 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
2599 #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
2600 for (; i < last_index; i++) {
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
2601 int level = block[ scan_table[i] ];
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
2602 if (level) {
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
2603 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
2604 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
2605 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
2606 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
2607 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
2608 }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
2609 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
2610 }
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
2611 last_non_zero = i;
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
2612 }
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
2613 }
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
2614 /*if(i<=last_index)*/{
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
2615 int level = block[ scan_table[i] ];
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
2616 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
2617 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
2618 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
2619 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
2620 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
2621 }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
2622 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
2623 }
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
2624 }
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
2625 #else
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2626 for (; i <= last_index; i++) {
648
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
2627 const int slevel = block[ scan_table[i] ];
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
2628 if (slevel) {
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
2629 int level;
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
2630 int run = i - last_non_zero - 1;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2631 last = (i == last_index);
986e461dc072 Initial revision
glantau
parents:
diff changeset
2632 sign = 0;
648
dddcff6841f2 optimizing mpeg4_encode_block(), generates allso slightly shorter bitstream as some codes can be represented as esc1 and esc2 and esc2 is shorter for a few of them
michaelni
parents: 619
diff changeset
2633 level = slevel;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2634 if (level < 0) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
2635 sign = 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2636 level = -level;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2637 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
2638 code = get_rl_index(rl, last, run, level);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2639 put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2640 if (code == rl->n) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
2641 int level1, run1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2642 level1 = level - rl->max_level[last][run];
986e461dc072 Initial revision
glantau
parents:
diff changeset
2643 if (level1 < 1)
986e461dc072 Initial revision
glantau
parents:
diff changeset
2644 goto esc2;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2645 code = get_rl_index(rl, last, run, level1);
986e461dc072 Initial revision
glantau
parents:
diff changeset
2646 if (code == rl->n) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
2647 esc2:
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2648 put_bits(ac_pb, 1, 1);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2649 if (level > MAX_LEVEL)
986e461dc072 Initial revision
glantau
parents:
diff changeset
2650 goto esc3;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2651 run1 = run - rl->max_run[last][level] - 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2652 if (run1 < 0)
986e461dc072 Initial revision
glantau
parents:
diff changeset
2653 goto esc3;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2654 code = get_rl_index(rl, last, run1, level);
986e461dc072 Initial revision
glantau
parents:
diff changeset
2655 if (code == rl->n) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
2656 esc3:
986e461dc072 Initial revision
glantau
parents:
diff changeset
2657 /* third escape */
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2658 put_bits(ac_pb, 1, 1);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2659 put_bits(ac_pb, 1, last);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2660 put_bits(ac_pb, 6, run);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2661 put_bits(ac_pb, 1, 1);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2662 put_bits(ac_pb, 12, slevel & 0xfff);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2663 put_bits(ac_pb, 1, 1);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2664 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
2665 /* second escape */
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2666 put_bits(ac_pb, 1, 0);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2667 put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2668 put_bits(ac_pb, 1, sign);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2669 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
2670 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
2671 /* first escape */
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2672 put_bits(ac_pb, 1, 0);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2673 put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2674 put_bits(ac_pb, 1, sign);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2675 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
2676 } else {
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2677 put_bits(ac_pb, 1, sign);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2678 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
2679 last_non_zero = i;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2680 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
2681 }
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
2682 #endif
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2683 }
936
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2684
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2685 static inline int mpeg4_get_block_length(MpegEncContext * s, DCTELEM * block, int n, int intra_dc,
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
2686 uint8_t *scan_table)
936
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2687 {
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2688 int i, last_non_zero;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2689 const RLTable *rl;
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
2690 uint8_t *len_tab;
936
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2691 const int last_index = s->block_last_index[n];
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2692 int len=0;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2693
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2694 if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2695 /* mpeg4 based DC predictor */
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2696 //mpeg4_encode_dc(dc_pb, intra_dc, n); //FIXME
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2697 if(last_index<1) return len;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2698 i = 1;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2699 rl = &rl_intra;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2700 len_tab = uni_mpeg4_intra_rl_len;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2701 } else {
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2702 if(last_index<0) return 0;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2703 i = 0;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2704 rl = &rl_inter;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2705 len_tab = uni_mpeg4_inter_rl_len;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2706 }
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2707
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2708 /* AC coefs */
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2709 last_non_zero = i - 1;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2710 for (; i < last_index; i++) {
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2711 int level = block[ scan_table[i] ];
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2712 if (level) {
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2713 int run = i - last_non_zero - 1;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2714 level+=64;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2715 if((level&(~127)) == 0){
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2716 const int index= UNI_MPEG4_ENC_INDEX(0, run, level);
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2717 len += len_tab[index];
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2718 }else{ //ESC3
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2719 len += 7+2+1+6+1+12+1;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2720 }
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2721 last_non_zero = i;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2722 }
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2723 }
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2724 /*if(i<=last_index)*/{
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2725 int level = block[ scan_table[i] ];
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2726 int run = i - last_non_zero - 1;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2727 level+=64;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2728 if((level&(~127)) == 0){
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2729 const int index= UNI_MPEG4_ENC_INDEX(1, run, level);
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2730 len += len_tab[index];
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2731 }else{ //ESC3
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2732 len += 7+2+1+6+1+12+1;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2733 }
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2734 }
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2735
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2736 return len;
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2737 }
caa77cd960c0 qpel encoding
michaelni
parents: 930
diff changeset
2738
815
78accc54493b put a few large tables under #ifdef CONFIG_ENCODERS or dynamically allocate them
michaelni
parents: 770
diff changeset
2739 #endif
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2740
986e461dc072 Initial revision
glantau
parents:
diff changeset
2741
986e461dc072 Initial revision
glantau
parents:
diff changeset
2742 /***********************************************/
986e461dc072 Initial revision
glantau
parents:
diff changeset
2743 /* decoding */
986e461dc072 Initial revision
glantau
parents:
diff changeset
2744
986e461dc072 Initial revision
glantau
parents:
diff changeset
2745 static VLC intra_MCBPC_vlc;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2746 static VLC inter_MCBPC_vlc;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2747 static VLC cbpy_vlc;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2748 static VLC mv_vlc;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2749 static VLC dc_lum, dc_chrom;
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
2750 static VLC sprite_trajectory;
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2751 static VLC mb_type_b_vlc;
1655
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
2752 static VLC h263_mbtype_b_vlc;
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
2753 static VLC cbpc_b_vlc;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2754
986e461dc072 Initial revision
glantau
parents:
diff changeset
2755 void init_vlc_rl(RLTable *rl)
986e461dc072 Initial revision
glantau
parents:
diff changeset
2756 {
542
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2757 int i, q;
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2758
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2759 init_vlc(&rl->vlc, 9, rl->n + 1,
986e461dc072 Initial revision
glantau
parents:
diff changeset
2760 &rl->table_vlc[0][1], 4, 2,
986e461dc072 Initial revision
glantau
parents:
diff changeset
2761 &rl->table_vlc[0][0], 4, 2);
542
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2762
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2763
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2764 for(q=0; q<32; q++){
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2765 int qmul= q*2;
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2766 int qadd= (q-1)|1;
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2767
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2768 if(q==0){
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2769 qmul=1;
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2770 qadd=0;
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2771 }
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2772
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2773 rl->rl_vlc[q]= av_malloc(rl->vlc.table_size*sizeof(RL_VLC_ELEM));
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2774 for(i=0; i<rl->vlc.table_size; i++){
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2775 int code= rl->vlc.table[i][0];
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2776 int len = rl->vlc.table[i][1];
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2777 int level, run;
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2778
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2779 if(len==0){ // illegal code
563
61442627f857 fixes fire.avi & subtitles.avi
michaelni
parents: 549
diff changeset
2780 run= 66;
542
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2781 level= MAX_LEVEL;
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2782 }else if(len<0){ //more bits needed
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2783 run= 0;
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2784 level= code;
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2785 }else{
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2786 if(code==rl->n){ //esc
563
61442627f857 fixes fire.avi & subtitles.avi
michaelni
parents: 549
diff changeset
2787 run= 66;
542
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2788 level= 0;
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2789 }else{
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2790 run= rl->table_run [code] + 1;
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2791 level= rl->table_level[code] * qmul + qadd;
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2792 if(code >= rl->last) run+=192;
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2793 }
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2794 }
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2795 rl->rl_vlc[q][i].len= len;
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2796 rl->rl_vlc[q][i].level= level;
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2797 rl->rl_vlc[q][i].run= run;
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2798 }
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 523
diff changeset
2799 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2800 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
2801
986e461dc072 Initial revision
glantau
parents:
diff changeset
2802 /* init vlcs */
986e461dc072 Initial revision
glantau
parents:
diff changeset
2803
986e461dc072 Initial revision
glantau
parents:
diff changeset
2804 /* XXX: find a better solution to handle static init */
986e461dc072 Initial revision
glantau
parents:
diff changeset
2805 void h263_decode_init_vlc(MpegEncContext *s)
986e461dc072 Initial revision
glantau
parents:
diff changeset
2806 {
986e461dc072 Initial revision
glantau
parents:
diff changeset
2807 static int done = 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2808
986e461dc072 Initial revision
glantau
parents:
diff changeset
2809 if (!done) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
2810 done = 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
2811
1482
b372ecde32a8 h263 stuffing decode fix
michaelni
parents: 1457
diff changeset
2812 init_vlc(&intra_MCBPC_vlc, INTRA_MCBPC_VLC_BITS, 9,
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2813 intra_MCBPC_bits, 1, 1,
986e461dc072 Initial revision
glantau
parents:
diff changeset
2814 intra_MCBPC_code, 1, 1);
1482
b372ecde32a8 h263 stuffing decode fix
michaelni
parents: 1457
diff changeset
2815 init_vlc(&inter_MCBPC_vlc, INTER_MCBPC_VLC_BITS, 28,
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2816 inter_MCBPC_bits, 1, 1,
986e461dc072 Initial revision
glantau
parents:
diff changeset
2817 inter_MCBPC_code, 1, 1);
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
2818 init_vlc(&cbpy_vlc, CBPY_VLC_BITS, 16,
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2819 &cbpy_tab[0][1], 2, 1,
986e461dc072 Initial revision
glantau
parents:
diff changeset
2820 &cbpy_tab[0][0], 2, 1);
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
2821 init_vlc(&mv_vlc, MV_VLC_BITS, 33,
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2822 &mvtab[0][1], 2, 1,
986e461dc072 Initial revision
glantau
parents:
diff changeset
2823 &mvtab[0][0], 2, 1);
986e461dc072 Initial revision
glantau
parents:
diff changeset
2824 init_rl(&rl_inter);
986e461dc072 Initial revision
glantau
parents:
diff changeset
2825 init_rl(&rl_intra);
1132
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
2826 init_rl(&rvlc_rl_inter);
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
2827 init_rl(&rvlc_rl_intra);
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
2828 init_rl(&rl_intra_aic);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2829 init_vlc_rl(&rl_inter);
986e461dc072 Initial revision
glantau
parents:
diff changeset
2830 init_vlc_rl(&rl_intra);
1132
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
2831 init_vlc_rl(&rvlc_rl_inter);
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
2832 init_vlc_rl(&rvlc_rl_intra);
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
2833 init_vlc_rl(&rl_intra_aic);
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
2834 init_vlc(&dc_lum, DC_VLC_BITS, 10 /* 13 */,
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2835 &DCtab_lum[0][1], 2, 1,
986e461dc072 Initial revision
glantau
parents:
diff changeset
2836 &DCtab_lum[0][0], 2, 1);
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
2837 init_vlc(&dc_chrom, DC_VLC_BITS, 10 /* 13 */,
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2838 &DCtab_chrom[0][1], 2, 1,
986e461dc072 Initial revision
glantau
parents:
diff changeset
2839 &DCtab_chrom[0][0], 2, 1);
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
2840 init_vlc(&sprite_trajectory, SPRITE_TRAJ_VLC_BITS, 15,
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
2841 &sprite_trajectory_tab[0][1], 4, 2,
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
2842 &sprite_trajectory_tab[0][0], 4, 2);
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
2843 init_vlc(&mb_type_b_vlc, MB_TYPE_B_VLC_BITS, 4,
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2844 &mb_type_b_tab[0][1], 2, 1,
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
2845 &mb_type_b_tab[0][0], 2, 1);
1655
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
2846 init_vlc(&h263_mbtype_b_vlc, H263_MBTYPE_B_VLC_BITS, 15,
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
2847 &h263_mbtype_b_tab[0][1], 2, 1,
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
2848 &h263_mbtype_b_tab[0][0], 2, 1);
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
2849 init_vlc(&cbpc_b_vlc, CBPC_B_VLC_BITS, 4,
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
2850 &cbpc_b_tab[0][1], 2, 1,
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
2851 &cbpc_b_tab[0][0], 2, 1);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
2852 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
2853 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
2854
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2855 /**
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2856 * 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
2857 */
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2858 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
2859 if (s->height <= 400)
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2860 return 1;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2861 else if (s->height <= 800)
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2862 return 2;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2863 else
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2864 return 4;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2865 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2866
1661
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
2867 int ff_h263_decode_mba(MpegEncContext *s)
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
2868 {
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
2869 int i, mb_pos;
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
2870
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
2871 for(i=0; i<6; i++){
1670
d6f2520c0c43 slice structured fixes
michael
parents: 1668
diff changeset
2872 if(s->mb_num-1 <= ff_mba_max[i]) break;
1661
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
2873 }
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
2874 mb_pos= get_bits(&s->gb, ff_mba_length[i]);
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
2875 s->mb_x= mb_pos % s->mb_width;
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
2876 s->mb_y= mb_pos / s->mb_width;
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
2877
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
2878 return mb_pos;
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
2879 }
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
2880
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
2881 void ff_h263_encode_mba(MpegEncContext *s)
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
2882 {
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
2883 int i, mb_pos;
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
2884
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
2885 for(i=0; i<6; i++){
1670
d6f2520c0c43 slice structured fixes
michael
parents: 1668
diff changeset
2886 if(s->mb_num-1 <= ff_mba_max[i]) break;
1661
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
2887 }
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
2888 mb_pos= s->mb_x + s->mb_width*s->mb_y;
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
2889 put_bits(&s->pb, ff_mba_length[i], mb_pos);
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
2890 }
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
2891
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2892 /**
1661
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
2893 * decodes the group of blocks header or slice header.
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2894 * @return <0 if an error occured
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2895 */
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2896 static int h263_decode_gob_header(MpegEncContext *s)
162
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
2897 {
1661
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
2898 unsigned int val, gfid, gob_number;
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2899 int left;
162
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
2900
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
2901 /* Check for GOB Start Code */
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
2902 val = show_bits(&s->gb, 16);
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2903 if(val)
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2904 return -1;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2905
162
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
2906 /* 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
2907 skip_bits(&s->gb, 16); /* Drop the zeros */
1025
1f9afd8b9131 GetBitContext.size is allways multiplied by 8 -> use size_in_bits to avoid useless *8 in a few inner loops
michaelni
parents: 1013
diff changeset
2908 left= s->gb.size_in_bits - get_bits_count(&s->gb);
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2909 //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
2910 for(;left>13; left--){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2911 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
2912 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2913 if(left<=13)
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2914 return -1;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2915
1661
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
2916 if(s->h263_slice_structured){
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
2917 if(get_bits1(&s->gb)==0)
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
2918 return -1;
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
2919
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
2920 ff_h263_decode_mba(s);
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
2921
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
2922 if(s->mb_num > 1583)
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
2923 if(get_bits1(&s->gb)==0)
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
2924 return -1;
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
2925
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
2926 s->qscale = get_bits(&s->gb, 5); /* SQUANT */
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
2927 if(get_bits1(&s->gb)==0)
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
2928 return -1;
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
2929 gfid = get_bits(&s->gb, 2); /* GFID */
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
2930 }else{
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
2931 gob_number = get_bits(&s->gb, 5); /* GN */
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
2932 s->mb_x= 0;
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
2933 s->mb_y= s->gob_index* gob_number;
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
2934 gfid = get_bits(&s->gb, 2); /* GFID */
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
2935 s->qscale = get_bits(&s->gb, 5); /* GQUANT */
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
2936 }
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
2937
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
2938 if(s->mb_y >= s->mb_height)
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
2939 return -1;
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
2940
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2941 if(s->qscale==0)
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2942 return -1;
1644
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
2943
162
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
2944 return 0;
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
2945 }
de80712db90b - Preliminary RTP friendly mode for H.263.
pulento
parents: 161
diff changeset
2946
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2947 static inline void memsetw(short *tab, int val, int n)
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2948 {
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2949 int i;
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2950 for(i=0;i<n;i++)
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2951 tab[i] = val;
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2952 }
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2953
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
2954 #ifdef CONFIG_ENCODERS
6da5ae9ee199 more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents: 1068
diff changeset
2955
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2956 void ff_mpeg4_init_partitions(MpegEncContext *s)
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2957 {
1522
79dddc5cd990 removed the obsolete and unused parameters of init_put_bits
alex
parents: 1521
diff changeset
2958 init_put_bits(&s->tex_pb, s->tex_pb_buffer, PB_BUFFER_SIZE);
79dddc5cd990 removed the obsolete and unused parameters of init_put_bits
alex
parents: 1521
diff changeset
2959 init_put_bits(&s->pb2 , s->pb2_buffer , PB_BUFFER_SIZE);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2960 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2961
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2962 void ff_mpeg4_merge_partitions(MpegEncContext *s)
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
2963 {
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2964 const int pb2_len = get_bit_count(&s->pb2 );
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2965 const int tex_pb_len= get_bit_count(&s->tex_pb);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2966 const int bits= get_bit_count(&s->pb);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2967
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2968 if(s->pict_type==I_TYPE){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2969 put_bits(&s->pb, 19, DC_MARKER);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2970 s->misc_bits+=19 + pb2_len + bits - s->last_bits;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2971 s->i_tex_bits+= tex_pb_len;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2972 }else{
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2973 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
2974 s->misc_bits+=17 + pb2_len;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2975 s->mv_bits+= bits - s->last_bits;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2976 s->p_tex_bits+= tex_pb_len;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2977 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2978
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2979 flush_put_bits(&s->pb2);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2980 flush_put_bits(&s->tex_pb);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2981
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2982 ff_copy_bits(&s->pb, s->pb2_buffer , pb2_len);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2983 ff_copy_bits(&s->pb, s->tex_pb_buffer, tex_pb_len);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2984 s->last_bits= get_bit_count(&s->pb);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2985 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
2986
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
2987 #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
2988
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2989 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
2990 switch(s->pict_type){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2991 case I_TYPE:
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2992 return 16;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2993 case P_TYPE:
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2994 case S_TYPE:
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2995 return s->f_code+15;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2996 case B_TYPE:
847
f3c369b8ddca reversing header game
michaelni
parents: 821
diff changeset
2997 return FFMAX(FFMAX(s->f_code, s->b_code)+15, 17);
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2998 default:
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
2999 return -1;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3000 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3001 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3002
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
3003 #ifdef CONFIG_ENCODERS
6da5ae9ee199 more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents: 1068
diff changeset
3004
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3005 void ff_mpeg4_encode_video_packet_header(MpegEncContext *s)
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3006 {
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3007 int mb_num_bits= av_log2(s->mb_num - 1) + 1;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3008
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3009 put_bits(&s->pb, ff_mpeg4_get_video_packet_prefix_length(s), 0);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3010 put_bits(&s->pb, 1, 1);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3011
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3012 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
3013 put_bits(&s->pb, s->quant_precision, s->qscale);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3014 put_bits(&s->pb, 1, 0); /* no HEC */
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3015 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3016
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
3017 #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
3018
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3019 /**
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3020 * 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
3021 * @return 0 if not
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3022 */
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3023 static inline int mpeg4_is_resync(MpegEncContext *s){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3024 const int bits_count= get_bits_count(&s->gb);
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3025
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3026 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
3027 return 0;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3028 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3029
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
3030 if(bits_count + 8 >= s->gb.size_in_bits){
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3031 int v= show_bits(&s->gb, 8);
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3032 v|= 0x7F >> (7-(bits_count&7));
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3033
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3034 if(v==0x7F)
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3035 return 1;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3036 }else{
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3037 if(show_bits(&s->gb, 16) == ff_mpeg4_resync_prefix[bits_count&7]){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3038 int len;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3039 GetBitContext gb= s->gb;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3040
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3041 skip_bits(&s->gb, 1);
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3042 align_get_bits(&s->gb);
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3043
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3044 for(len=0; len<32; len++){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3045 if(get_bits1(&s->gb)) break;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3046 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3047
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3048 s->gb= gb;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3049
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3050 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
3051 return 1;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3052 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3053 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3054 return 0;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3055 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3056
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3057 /**
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3058 * decodes the next video packet.
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3059 * @return <0 if something went wrong
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3060 */
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3061 static int mpeg4_decode_video_packet_header(MpegEncContext *s)
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3062 {
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
3063 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
3064 int header_extension=0, mb_num, len;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3065
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3066 /* 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
3067 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
3068
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3069 for(len=0; len<32; len++){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3070 if(get_bits1(&s->gb)) break;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3071 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3072
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3073 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
3074 av_log(s->avctx, AV_LOG_ERROR, "marker does not match f_code\n");
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3075 return -1;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3076 }
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3077
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3078 if(s->shape != RECT_SHAPE){
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3079 header_extension= get_bits1(&s->gb);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3080 //FIXME more stuff here
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3081 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3082
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3083 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
3084 if(mb_num>=s->mb_num){
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1586
diff changeset
3085 av_log(s->avctx, AV_LOG_ERROR, "illegal mb_num in video packet (%d %d) \n", mb_num, s->mb_num);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3086 return -1;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3087 }
1176
a39d55237445 b frames + slices bugfix
michaelni
parents: 1164
diff changeset
3088 if(s->pict_type == B_TYPE){
1177
fea03d2c4946 simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents: 1176
diff changeset
3089 while(s->next_picture.mbskip_table[ s->mb_index2xy[ mb_num ] ]) mb_num++;
1176
a39d55237445 b frames + slices bugfix
michaelni
parents: 1164
diff changeset
3090 if(mb_num >= s->mb_num) return -1; // slice contains just skiped MBs which where allready decoded
a39d55237445 b frames + slices bugfix
michaelni
parents: 1164
diff changeset
3091 }
a39d55237445 b frames + slices bugfix
michaelni
parents: 1164
diff changeset
3092
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3093 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
3094 s->mb_y= mb_num / s->mb_width;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3095
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3096 if(s->shape != BIN_ONLY_SHAPE){
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3097 int qscale= get_bits(&s->gb, s->quant_precision);
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3098 if(qscale)
1644
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
3099 s->chroma_qscale=s->qscale= qscale;
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
3100 }
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
3101
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
3102 if(s->shape == RECT_SHAPE){
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3103 header_extension= get_bits1(&s->gb);
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
3104 }
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
3105 if(header_extension){
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3106 int time_increment;
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
3107 int time_incr=0;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3108
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3109 while (get_bits1(&s->gb) != 0)
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
3110 time_incr++;
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
3111
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3112 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
3113 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
3114 check_marker(&s->gb, "before vop_coding_type in video packed header");
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
3115
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3116 skip_bits(&s->gb, 2); /* vop coding type */
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
3117 //FIXME not rect stuff here
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
3118
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
3119 if(s->shape != BIN_ONLY_SHAPE){
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3120 skip_bits(&s->gb, 3); /* intra dc vlc threshold */
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3121 //FIXME dont just ignore everything
821
f5f2e162331c hopefully fixing sprite_warping_points==0
michaelni
parents: 815
diff changeset
3122 if(s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
3123 mpeg4_decode_sprite_trajectory(s);
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1586
diff changeset
3124 av_log(s->avctx, AV_LOG_ERROR, "untested\n");
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
3125 }
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
3126
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
3127 //FIXME reduced res stuff here
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
3128
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
3129 if (s->pict_type != I_TYPE) {
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3130 int f_code = get_bits(&s->gb, 3); /* fcode_for */
660
b8e268337a1d parsing resync header extension support
michaelni
parents: 659
diff changeset
3131 if(f_code==0){
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1586
diff changeset
3132 av_log(s->avctx, AV_LOG_ERROR, "Error, video packet header damaged (f_code=0)\n");
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
3133 }
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
3134 }
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
3135 if (s->pict_type == B_TYPE) {
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3136 int b_code = get_bits(&s->gb, 3);
660
b8e268337a1d parsing resync header extension support
michaelni
parents: 659
diff changeset
3137 if(b_code==0){
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1586
diff changeset
3138 av_log(s->avctx, AV_LOG_ERROR, "Error, video packet header damaged (b_code=0)\n");
660
b8e268337a1d parsing resync header extension support
michaelni
parents: 659
diff changeset
3139 }
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
3140 }
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
3141 }
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
3142 }
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
3143 //FIXME new-pred stuff
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3144
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3145 //printf("parse ok %d %d %d %d\n", mb_num, s->mb_x + s->mb_y*s->mb_width, get_bits_count(gb), get_bits_count(&s->gb));
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3146
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3147 return 0;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3148 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3149
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3150 void ff_mpeg4_clean_buffers(MpegEncContext *s)
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3151 {
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3152 int c_wrap, c_xy, l_wrap, l_xy;
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
3153
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
3154 l_wrap= s->block_wrap[0];
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3155 l_xy= s->mb_y*l_wrap*2 + s->mb_x*2;
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
3156 c_wrap= s->block_wrap[4];
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3157 c_xy= s->mb_y*c_wrap + s->mb_x;
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
3158
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3159 #if 0
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
3160 /* clean DC */
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3161 memsetw(s->dc_val[0] + l_xy, 1024, l_wrap*2+1);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3162 memsetw(s->dc_val[1] + c_xy, 1024, c_wrap+1);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3163 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
3164 #endif
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
3165
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
3166 /* clean AC */
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
3167 memset(s->ac_val[0] + l_xy, 0, (l_wrap*2+1)*16*sizeof(int16_t));
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
3168 memset(s->ac_val[1] + c_xy, 0, (c_wrap +1)*16*sizeof(int16_t));
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
3169 memset(s->ac_val[2] + c_xy, 0, (c_wrap +1)*16*sizeof(int16_t));
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
3170
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
3171 /* clean MV */
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3172 // we cant clear the MVs as they might be needed by a b frame
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
3173 // memset(s->motion_val + l_xy, 0, (l_wrap*2+1)*2*sizeof(int16_t));
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
3174 // memset(s->motion_val, 0, 2*sizeof(int16_t)*(2 + s->mb_width*2)*(2 + s->mb_height*2));
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3175 s->last_mv[0][0][0]=
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3176 s->last_mv[0][0][1]=
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3177 s->last_mv[1][0][0]=
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3178 s->last_mv[1][0][1]= 0;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3179 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3180
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3181 /**
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3182 * decodes the group of blocks / video packet header.
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3183 * @return <0 if no resync found
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3184 */
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3185 int ff_h263_resync(MpegEncContext *s){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3186 int left, ret;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3187
1521
c232b6753012 h263 GOB decoding fix
michael
parents: 1520
diff changeset
3188 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
3189 skip_bits1(&s->gb);
1521
c232b6753012 h263 GOB decoding fix
michael
parents: 1520
diff changeset
3190 align_get_bits(&s->gb);
c232b6753012 h263 GOB decoding fix
michael
parents: 1520
diff changeset
3191 }
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3192
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3193 if(show_bits(&s->gb, 16)==0){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3194 if(s->codec_id==CODEC_ID_MPEG4)
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3195 ret= mpeg4_decode_video_packet_header(s);
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3196 else
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3197 ret= h263_decode_gob_header(s);
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3198 if(ret>=0)
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3199 return 0;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3200 }
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3201 //ok, its not where its supposed to be ...
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3202 s->gb= s->last_resync_gb;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3203 align_get_bits(&s->gb);
1025
1f9afd8b9131 GetBitContext.size is allways multiplied by 8 -> use size_in_bits to avoid useless *8 in a few inner loops
michaelni
parents: 1013
diff changeset
3204 left= s->gb.size_in_bits - get_bits_count(&s->gb);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3205
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3206 for(;left>16+1+5+5; left-=8){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3207 if(show_bits(&s->gb, 16)==0){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3208 GetBitContext bak= s->gb;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3209
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3210 if(s->codec_id==CODEC_ID_MPEG4)
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3211 ret= mpeg4_decode_video_packet_header(s);
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3212 else
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3213 ret= h263_decode_gob_header(s);
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3214 if(ret>=0)
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3215 return 0;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3216
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3217 s->gb= bak;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3218 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3219 skip_bits(&s->gb, 8);
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3220 }
1671
a75cbb4588d1 100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l100l
michael
parents: 1670
diff changeset
3221
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3222 return -1;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3223 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3224
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3225 /**
1034
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
3226 * gets the average motion vector for a GMC MB.
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3227 * @param n either 0 for the x component or 1 for y
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3228 * @returns the average MV for a GMC MB
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3229 */
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3230 static inline int get_amv(MpegEncContext *s, int n){
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3231 int x, y, mb_v, sum, dx, dy, shift;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3232 int len = 1 << (s->f_code + 4);
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3233 const int a= s->sprite_warping_accuracy;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3234
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3235 if(s->real_sprite_warping_points==1){
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3236 if(s->divx_version==500 && s->divx_build==413)
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3237 sum= s->sprite_offset[0][n] / (1<<(a - s->quarter_sample));
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3238 else
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3239 sum= RSHIFT(s->sprite_offset[0][n]<<s->quarter_sample, a);
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3240 }else{
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3241 dx= s->sprite_delta[n][0];
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3242 dy= s->sprite_delta[n][1];
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3243 shift= s->sprite_shift[0];
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3244 if(n) dy -= 1<<(shift + a + 1);
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3245 else dx -= 1<<(shift + a + 1);
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3246 mb_v= s->sprite_offset[0][n] + dx*s->mb_x*16 + dy*s->mb_y*16;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3247
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3248 sum=0;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3249 for(y=0; y<16; y++){
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3250 int v;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3251
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3252 v= mb_v + dy*y;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3253 //XXX FIXME optimize
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3254 for(x=0; x<16; x++){
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3255 sum+= v>>shift;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3256 v+= dx;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3257 }
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3258 }
999
74dc4105e147 average motion vector rounding like the reference says and not what the standard says
michaelni
parents: 953
diff changeset
3259 sum= RSHIFT(sum, a+8-s->quarter_sample);
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3260 }
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3261
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3262 if (sum < -len) sum= -len;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3263 else if (sum >= len) sum= len-1;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3264
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3265 return sum;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3266 }
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3267
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3268 /**
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3269 * decodes first partition.
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3270 * @return number of MBs decoded or <0 if an error occured
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3271 */
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3272 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
3273 int mb_num;
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
3274 static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3275
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3276 /* decode first partition */
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3277 mb_num=0;
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
3278 s->first_slice_line=1;
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3279 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
3280 ff_init_block_index(s);
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3281 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
3282 const int xy= s->mb_x + s->mb_y*s->mb_stride;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3283 int cbpc;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3284 int dir=0;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3285
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3286 mb_num++;
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3287 ff_update_block_index(s);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3288 if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3289 s->first_slice_line=0;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3290
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3291 if(s->pict_type==I_TYPE){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3292 int i;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3293
1257
6defe392d5d2 libmpeg2 style bitstream reader fixes
michaelni
parents: 1255
diff changeset
3294 if(show_bits_long(&s->gb, 19)==DC_MARKER){
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3295 return mb_num-1;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3296 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3297
1482
b372ecde32a8 h263 stuffing decode fix
michaelni
parents: 1457
diff changeset
3298 do{
b372ecde32a8 h263 stuffing decode fix
michaelni
parents: 1457
diff changeset
3299 cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
b372ecde32a8 h263 stuffing decode fix
michaelni
parents: 1457
diff changeset
3300 if (cbpc < 0){
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1586
diff changeset
3301 av_log(s->avctx, AV_LOG_ERROR, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
1482
b372ecde32a8 h263 stuffing decode fix
michaelni
parents: 1457
diff changeset
3302 return -1;
b372ecde32a8 h263 stuffing decode fix
michaelni
parents: 1457
diff changeset
3303 }
b372ecde32a8 h263 stuffing decode fix
michaelni
parents: 1457
diff changeset
3304 }while(cbpc == 8);
b372ecde32a8 h263 stuffing decode fix
michaelni
parents: 1457
diff changeset
3305
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3306 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
3307 s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3308 s->mb_intra = 1;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3309
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3310 if(cbpc & 4) {
1652
834922115010 cleanup
michael
parents: 1649
diff changeset
3311 ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3312 }
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
3313 s->current_picture.qscale_table[xy]= s->qscale;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3314
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3315 s->mbintra_table[xy]= 1;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3316 for(i=0; i<6; i++){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3317 int dc_pred_dir;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3318 int dc= mpeg4_decode_dc(s, i, &dc_pred_dir);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3319 if(dc < 0){
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1586
diff changeset
3320 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
3321 return -1;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3322 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3323 dir<<=1;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3324 if(dc_pred_dir) dir|=1;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3325 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3326 s->pred_dir_table[xy]= dir;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3327 }else{ /* P/S_TYPE */
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3328 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
3329 int16_t * const mot_val= s->current_picture.motion_val[0][s->block_index[0]];
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3330 const int stride= s->block_wrap[0]*2;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3331
1483
michaelni
parents: 1482
diff changeset
3332 // do{ //FIXME
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3333 bits= show_bits(&s->gb, 17);
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3334 if(bits==MOTION_MARKER){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3335 return mb_num-1;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3336 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3337 skip_bits1(&s->gb);
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3338 if(bits&0x10000){
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3339 /* skip mb */
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3340 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
1177
fea03d2c4946 simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents: 1176
diff changeset
3341 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0;
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3342 mx= get_amv(s, 0);
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3343 my= get_amv(s, 1);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3344 }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
3345 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3346 mx=my=0;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3347 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3348 mot_val[0 ]= mot_val[2 ]=
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3349 mot_val[0+stride]= mot_val[2+stride]= mx;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3350 mot_val[1 ]= mot_val[3 ]=
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3351 mot_val[1+stride]= mot_val[3+stride]= my;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3352
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3353 if(s->mbintra_table[xy])
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3354 ff_clean_intra_table_entries(s);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3355 continue;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3356 }
1482
b372ecde32a8 h263 stuffing decode fix
michaelni
parents: 1457
diff changeset
3357
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
3358 cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3359 if (cbpc < 0){
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1586
diff changeset
3360 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
3361 return -1;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3362 }
1483
michaelni
parents: 1482
diff changeset
3363 // }while(cbpc == 20);
1482
b372ecde32a8 h263 stuffing decode fix
michaelni
parents: 1457
diff changeset
3364
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3365 s->cbp_table[xy]= cbpc&(8+3); //8 is dquant
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3366
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3367 s->mb_intra = ((cbpc & 4) != 0);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3368
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3369 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
3370 s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3371 s->mbintra_table[xy]= 1;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3372 mot_val[0 ]= mot_val[2 ]=
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3373 mot_val[0+stride]= mot_val[2+stride]= 0;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3374 mot_val[1 ]= mot_val[3 ]=
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3375 mot_val[1+stride]= mot_val[3+stride]= 0;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3376 }else{
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3377 if(s->mbintra_table[xy])
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3378 ff_clean_intra_table_entries(s);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3379
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3380 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3381 s->mcsel= get_bits1(&s->gb);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3382 else s->mcsel= 0;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3383
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3384 if ((cbpc & 16) == 0) {
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3385 /* 16x16 motion prediction */
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3386
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3387 h263_pred_motion(s, 0, &pred_x, &pred_y);
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3388 if(!s->mcsel){
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3389 mx = h263_decode_motion(s, pred_x, s->f_code);
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3390 if (mx >= 0xffff)
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3391 return -1;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3392
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3393 my = h263_decode_motion(s, pred_y, s->f_code);
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3394 if (my >= 0xffff)
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3395 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
3396 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3397 } else {
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3398 mx = get_amv(s, 0);
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3399 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
3400 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3401 }
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
3402
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3403 mot_val[0 ]= mot_val[2 ] =
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3404 mot_val[0+stride]= mot_val[2+stride]= mx;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3405 mot_val[1 ]= mot_val[3 ]=
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3406 mot_val[1+stride]= mot_val[3+stride]= my;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3407 } else {
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3408 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
3409 s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3410 for(i=0;i<4;i++) {
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
3411 int16_t *mot_val= h263_pred_motion(s, i, &pred_x, &pred_y);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3412 mx = h263_decode_motion(s, pred_x, s->f_code);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3413 if (mx >= 0xffff)
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3414 return -1;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3415
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3416 my = h263_decode_motion(s, pred_y, s->f_code);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3417 if (my >= 0xffff)
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3418 return -1;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3419 mot_val[0] = mx;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3420 mot_val[1] = my;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3421 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3422 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3423 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3424 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3425 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3426 s->mb_x= 0;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3427 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3428
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3429 return mb_num;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3430 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3431
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3432 /**
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3433 * decode second partition.
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3434 * @return <0 if an error occured
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3435 */
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3436 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
3437 int mb_num=0;
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
3438 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
3439
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3440 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
3441 s->first_slice_line=1;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3442 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
3443 ff_init_block_index(s);
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3444 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
3445 const int xy= s->mb_x + s->mb_y*s->mb_stride;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3446
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3447 mb_num++;
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3448 ff_update_block_index(s);
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3449 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
3450 s->first_slice_line=0;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3451
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3452 if(s->pict_type==I_TYPE){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3453 int ac_pred= get_bits1(&s->gb);
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
3454 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3455 if(cbpy<0){
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1586
diff changeset
3456 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
3457 return -1;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3458 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3459
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3460 s->cbp_table[xy]|= cbpy<<2;
1177
fea03d2c4946 simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents: 1176
diff changeset
3461 s->current_picture.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3462 }else{ /* P || S_TYPE */
1177
fea03d2c4946 simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents: 1176
diff changeset
3463 if(IS_INTRA(s->current_picture.mb_type[xy])){
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3464 int dir=0,i;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3465 int ac_pred = get_bits1(&s->gb);
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
3466 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3467
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3468 if(cbpy<0){
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1586
diff changeset
3469 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
3470 return -1;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3471 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3472
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3473 if(s->cbp_table[xy] & 8) {
1652
834922115010 cleanup
michael
parents: 1649
diff changeset
3474 ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3475 }
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
3476 s->current_picture.qscale_table[xy]= s->qscale;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3477
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3478 for(i=0; i<6; i++){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3479 int dc_pred_dir;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3480 int dc= mpeg4_decode_dc(s, i, &dc_pred_dir);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3481 if(dc < 0){
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1586
diff changeset
3482 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
3483 return -1;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3484 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3485 dir<<=1;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3486 if(dc_pred_dir) dir|=1;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3487 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3488 s->cbp_table[xy]&= 3; //remove dquant
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3489 s->cbp_table[xy]|= cbpy<<2;
1177
fea03d2c4946 simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents: 1176
diff changeset
3490 s->current_picture.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED;
fea03d2c4946 simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents: 1176
diff changeset
3491 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
3492 }else if(IS_SKIP(s->current_picture.mb_type[xy])){
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
3493 s->current_picture.qscale_table[xy]= s->qscale;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3494 s->cbp_table[xy]= 0;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3495 }else{
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
3496 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3497
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3498 if(cbpy<0){
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1586
diff changeset
3499 av_log(s->avctx, AV_LOG_ERROR, "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
3500 return -1;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3501 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3502
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3503 if(s->cbp_table[xy] & 8) {
1652
834922115010 cleanup
michael
parents: 1649
diff changeset
3504 ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3505 }
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
3506 s->current_picture.qscale_table[xy]= s->qscale;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3507
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3508 s->cbp_table[xy]&= 3; //remove dquant
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3509 s->cbp_table[xy]|= (cbpy^0xf)<<2;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3510 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3511 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3512 }
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3513 if(mb_num >= mb_count) return 0;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3514 s->mb_x= 0;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3515 }
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3516 return 0;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3517 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3518
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3519 /**
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3520 * decodes the first & second partition
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3521 * @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
3522 */
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3523 int ff_mpeg4_decode_partitions(MpegEncContext *s)
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3524 {
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3525 int mb_num;
1144
21c85c4ab2f0 error resilience cleanup (its faster too...)
michaelni
parents: 1137
diff changeset
3526 const int part_a_error= s->pict_type==I_TYPE ? (DC_ERROR|MV_ERROR) : MV_ERROR;
21c85c4ab2f0 error resilience cleanup (its faster too...)
michaelni
parents: 1137
diff changeset
3527 const int part_a_end = s->pict_type==I_TYPE ? (DC_END |MV_END) : MV_END;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3528
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3529 mb_num= mpeg4_decode_partition_a(s);
1144
21c85c4ab2f0 error resilience cleanup (its faster too...)
michaelni
parents: 1137
diff changeset
3530 if(mb_num<0){
21c85c4ab2f0 error resilience cleanup (its faster too...)
michaelni
parents: 1137
diff changeset
3531 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
3532 return -1;
1144
21c85c4ab2f0 error resilience cleanup (its faster too...)
michaelni
parents: 1137
diff changeset
3533 }
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3534
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3535 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
3536 av_log(s->avctx, AV_LOG_ERROR, "slice below monitor ...\n");
1144
21c85c4ab2f0 error resilience cleanup (its faster too...)
michaelni
parents: 1137
diff changeset
3537 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
3538 return -1;
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
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3541 s->mb_num_left= mb_num;
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 if(s->pict_type==I_TYPE){
1257
6defe392d5d2 libmpeg2 style bitstream reader fixes
michaelni
parents: 1255
diff changeset
3544 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
3545 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
3546 return -1;
1144
21c85c4ab2f0 error resilience cleanup (its faster too...)
michaelni
parents: 1137
diff changeset
3547 }
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3548 }else{
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3549 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
3550 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
3551 return -1;
1144
21c85c4ab2f0 error resilience cleanup (its faster too...)
michaelni
parents: 1137
diff changeset
3552 }
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3553 }
1144
21c85c4ab2f0 error resilience cleanup (its faster too...)
michaelni
parents: 1137
diff changeset
3554 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, part_a_end);
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3555
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3556 if( mpeg4_decode_partition_b(s, mb_num) < 0){
1144
21c85c4ab2f0 error resilience cleanup (its faster too...)
michaelni
parents: 1137
diff changeset
3557 if(s->pict_type==P_TYPE)
21c85c4ab2f0 error resilience cleanup (its faster too...)
michaelni
parents: 1137
diff changeset
3558 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
3559 return -1;
1144
21c85c4ab2f0 error resilience cleanup (its faster too...)
michaelni
parents: 1137
diff changeset
3560 }else{
21c85c4ab2f0 error resilience cleanup (its faster too...)
michaelni
parents: 1137
diff changeset
3561 if(s->pict_type==P_TYPE)
21c85c4ab2f0 error resilience cleanup (its faster too...)
michaelni
parents: 1137
diff changeset
3562 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
3563 }
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3564
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3565 return 0;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3566 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3567
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3568 /**
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3569 * decode partition C of one MB.
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3570 * @return <0 if an error occured
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3571 */
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3572 static int mpeg4_decode_partitioned_mb(MpegEncContext *s, DCTELEM block[6][64])
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3573 {
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3574 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
3575 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
3576
fea03d2c4946 simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents: 1176
diff changeset
3577 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
3578 cbp = s->cbp_table[xy];
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3579
903
22ee74da2cd3 cleanup
michaelni
parents: 892
diff changeset
3580 if(s->current_picture.qscale_table[xy] != s->qscale){
1652
834922115010 cleanup
michael
parents: 1649
diff changeset
3581 ff_set_qscale(s, s->current_picture.qscale_table[xy] );
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3582 }
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3583
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3584 if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3585 int i;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3586 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
3587 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
3588 s->mv[0][i][1] = s->current_picture.motion_val[0][ s->block_index[i] ][1];
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3589 }
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
3590 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
3591
fea03d2c4946 simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents: 1176
diff changeset
3592 if (IS_SKIP(mb_type)) {
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3593 /* skip mb */
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3594 for(i=0;i<6;i++)
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3595 s->block_last_index[i] = -1;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3596 s->mv_dir = MV_DIR_FORWARD;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3597 s->mv_type = MV_TYPE_16X16;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3598 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3599 s->mcsel=1;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3600 s->mb_skiped = 0;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3601 }else{
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3602 s->mcsel=0;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3603 s->mb_skiped = 1;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3604 }
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3605 }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
3606 s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3607 }else if(!s->mb_intra){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3608 // s->mcsel= 0; //FIXME do we need to init that
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3609
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3610 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
3611 if (IS_8X8(mb_type)) {
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3612 s->mv_type = MV_TYPE_8X8;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3613 } else {
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3614 s->mv_type = MV_TYPE_16X16;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3615 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3616 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3617 } else { /* I-Frame */
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3618 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
3619 s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]);
1132
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
3620 }
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
3621
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
3622 if (!IS_SKIP(mb_type)) {
1132
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
3623 int i;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3624 /* decode each block */
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3625 for (i = 0; i < 6; i++) {
1132
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
3626 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
3627 av_log(s->avctx, AV_LOG_ERROR, "texture corrupted at %d %d %d\n", s->mb_x, s->mb_y, s->mb_intra);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3628 return -1;
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3629 }
718
16dab8296293 fixing custom quantizer matrix decoding
michaelni
parents: 706
diff changeset
3630 cbp+=cbp;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3631 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
3632 }
290
2899263586cd resync marker support, needed for some mp4 files
michaelni
parents: 287
diff changeset
3633
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3634 /* per-MB end of slice check */
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3635
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3636 if(--s->mb_num_left <= 0){
1025
1f9afd8b9131 GetBitContext.size is allways multiplied by 8 -> use size_in_bits to avoid useless *8 in a few inner loops
michaelni
parents: 1013
diff changeset
3637 //printf("%06X %d\n", show_bits(&s->gb, 24), s->gb.size_in_bits - get_bits_count(&s->gb));
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3638 if(mpeg4_is_resync(s))
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3639 return SLICE_END;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3640 else
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3641 return SLICE_NOEND;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3642 }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
3643 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
3644 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
3645 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
3646 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
3647 }
fea03d2c4946 simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents: 1176
diff changeset
3648 return SLICE_OK;
619
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
3649 }
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
3650 }
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3651
1633
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3652 /**
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3653 * read the next MVs for OBMC. yes this is a ugly hack, feel free to send a patch :)
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3654 */
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3655 static void preview_obmc(MpegEncContext *s){
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3656 GetBitContext gb= s->gb;
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3657
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3658 int cbpc, i, pred_x, pred_y, mx, my;
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3659 int16_t *mot_val;
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3660 const int xy= s->mb_x + 1 + s->mb_y * s->mb_stride;
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3661 const int stride= s->block_wrap[0]*2;
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3662
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3663 for(i=0; i<4; i++)
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3664 s->block_index[i]+= 2;
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3665 for(i=4; i<6; i++)
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3666 s->block_index[i]+= 1;
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3667 s->mb_x++;
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3668
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3669 assert(s->pict_type == P_TYPE);
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3670
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3671 do{
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3672 if (get_bits1(&s->gb)) {
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3673 /* 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
3674 mot_val = s->current_picture.motion_val[0][ s->block_index[0] ];
1633
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3675 mot_val[0 ]= mot_val[2 ]=
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3676 mot_val[0+stride]= mot_val[2+stride]= 0;
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3677 mot_val[1 ]= mot_val[3 ]=
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3678 mot_val[1+stride]= mot_val[3+stride]= 0;
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3679
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3680 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3681 goto end;
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3682 }
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3683 cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3684 }while(cbpc == 20);
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3685
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3686 if(cbpc & 4){
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3687 s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3688 }else{
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3689 get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3690 if (cbpc & 8) {
1656
34b0e799aeb6 cleanup
michael
parents: 1655
diff changeset
3691 if(s->modified_quant){
34b0e799aeb6 cleanup
michael
parents: 1655
diff changeset
3692 if(get_bits1(&s->gb)) skip_bits(&s->gb, 1);
34b0e799aeb6 cleanup
michael
parents: 1655
diff changeset
3693 else skip_bits(&s->gb, 5);
34b0e799aeb6 cleanup
michael
parents: 1655
diff changeset
3694 }else
34b0e799aeb6 cleanup
michael
parents: 1655
diff changeset
3695 skip_bits(&s->gb, 2);
1633
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3696 }
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3697
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3698 if ((cbpc & 16) == 0) {
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3699 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3700 /* 16x16 motion prediction */
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3701 mot_val= h263_pred_motion(s, 0, &pred_x, &pred_y);
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3702 if (s->umvplus)
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3703 mx = h263p_decode_umotion(s, pred_x);
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3704 else
1655
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3705 mx = h263_decode_motion(s, pred_x, 1);
1633
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3706
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3707 if (s->umvplus)
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3708 my = h263p_decode_umotion(s, pred_y);
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3709 else
1655
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3710 my = h263_decode_motion(s, pred_y, 1);
1633
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3711
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3712 mot_val[0 ]= mot_val[2 ]=
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3713 mot_val[0+stride]= mot_val[2+stride]= mx;
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3714 mot_val[1 ]= mot_val[3 ]=
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3715 mot_val[1+stride]= mot_val[3+stride]= my;
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3716 } else {
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3717 s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3718 for(i=0;i<4;i++) {
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3719 mot_val = h263_pred_motion(s, i, &pred_x, &pred_y);
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3720 if (s->umvplus)
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3721 mx = h263p_decode_umotion(s, pred_x);
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3722 else
1655
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3723 mx = h263_decode_motion(s, pred_x, 1);
1633
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3724
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3725 if (s->umvplus)
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3726 my = h263p_decode_umotion(s, pred_y);
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3727 else
1655
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3728 my = h263_decode_motion(s, pred_y, 1);
1633
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3729 if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3730 skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3731 mot_val[0] = mx;
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3732 mot_val[1] = my;
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3733 }
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3734 }
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3735 }
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3736 end:
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3737
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3738 for(i=0; i<4; i++)
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3739 s->block_index[i]-= 2;
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3740 for(i=4; i<6; i++)
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3741 s->block_index[i]-= 1;
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3742 s->mb_x--;
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3743
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3744 s->gb= gb;
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3745 }
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
3746
1656
34b0e799aeb6 cleanup
michael
parents: 1655
diff changeset
3747 static void h263_decode_dquant(MpegEncContext *s){
34b0e799aeb6 cleanup
michael
parents: 1655
diff changeset
3748 static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
34b0e799aeb6 cleanup
michael
parents: 1655
diff changeset
3749
34b0e799aeb6 cleanup
michael
parents: 1655
diff changeset
3750 if(s->modified_quant){
34b0e799aeb6 cleanup
michael
parents: 1655
diff changeset
3751 if(get_bits1(&s->gb))
34b0e799aeb6 cleanup
michael
parents: 1655
diff changeset
3752 s->qscale= modified_quant_tab[get_bits1(&s->gb)][ s->qscale ];
34b0e799aeb6 cleanup
michael
parents: 1655
diff changeset
3753 else
34b0e799aeb6 cleanup
michael
parents: 1655
diff changeset
3754 s->qscale= get_bits(&s->gb, 5);
34b0e799aeb6 cleanup
michael
parents: 1655
diff changeset
3755 }else
34b0e799aeb6 cleanup
michael
parents: 1655
diff changeset
3756 s->qscale += quant_tab[get_bits(&s->gb, 2)];
34b0e799aeb6 cleanup
michael
parents: 1655
diff changeset
3757 ff_set_qscale(s, s->qscale);
34b0e799aeb6 cleanup
michael
parents: 1655
diff changeset
3758 }
34b0e799aeb6 cleanup
michael
parents: 1655
diff changeset
3759
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3760 int ff_h263_decode_mb(MpegEncContext *s,
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
3761 DCTELEM block[6][64])
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3762 {
986e461dc072 Initial revision
glantau
parents:
diff changeset
3763 int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
3764 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
3765 const int xy= s->mb_x + s->mb_y * s->mb_stride;
1521
c232b6753012 h263 GOB decoding fix
michael
parents: 1520
diff changeset
3766
1649
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3767 assert(!s->h263_pred);
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3768
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3769 if (s->pict_type == P_TYPE) {
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3770 do{
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3771 if (get_bits1(&s->gb)) {
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3772 /* skip mb */
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3773 s->mb_intra = 0;
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3774 for(i=0;i<6;i++)
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3775 s->block_last_index[i] = -1;
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3776 s->mv_dir = MV_DIR_FORWARD;
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3777 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
3778 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
255
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
3779 s->mv[0][0][0] = 0;
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
3780 s->mv[0][0][1] = 0;
1644
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
3781 s->mb_skiped = !(s->obmc | s->loop_filter);
1649
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3782 goto end;
255
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
3783 }
1649
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3784 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
3785 //fprintf(stderr, "\tCBPC: %d", cbpc);
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3786 if (cbpc < 0){
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3787 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
3788 return -1;
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3789 }
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3790 }while(cbpc == 20);
144
cb5dabd00ba2 - Bug fix on inter MCBPC table for inter+q.
pulento
parents: 110
diff changeset
3791
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3792 dquant = cbpc & 8;
986e461dc072 Initial revision
glantau
parents:
diff changeset
3793 s->mb_intra = ((cbpc & 4) != 0);
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3794 if (s->mb_intra) goto intra;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
3795
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
3796 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
1637
7799582dc9b8 h263 alternative inter vlc support
michael
parents: 1633
diff changeset
3797
7799582dc9b8 h263 alternative inter vlc support
michael
parents: 1633
diff changeset
3798 if(s->alt_inter_vlc==0 || (cbpc & 3)!=3)
7799582dc9b8 h263 alternative inter vlc support
michael
parents: 1633
diff changeset
3799 cbpy ^= 0xF;
7799582dc9b8 h263 alternative inter vlc support
michael
parents: 1633
diff changeset
3800
7799582dc9b8 h263 alternative inter vlc support
michael
parents: 1633
diff changeset
3801 cbp = (cbpc & 3) | (cbpy << 2);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3802 if (dquant) {
1656
34b0e799aeb6 cleanup
michael
parents: 1655
diff changeset
3803 h263_decode_dquant(s);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
3804 }
1649
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3805
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3806 s->mv_dir = MV_DIR_FORWARD;
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3807 if ((cbpc & 16) == 0) {
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3808 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3809 /* 16x16 motion prediction */
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3810 s->mv_type = MV_TYPE_16X16;
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3811 h263_pred_motion(s, 0, &pred_x, &pred_y);
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3812 if (s->umvplus)
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3813 mx = h263p_decode_umotion(s, pred_x);
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3814 else
1655
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3815 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
3816
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3817 if (mx >= 0xffff)
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3818 return -1;
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3819
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3820 if (s->umvplus)
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3821 my = h263p_decode_umotion(s, pred_y);
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3822 else
1655
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3823 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
3824
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3825 if (my >= 0xffff)
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3826 return -1;
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3827 s->mv[0][0][0] = mx;
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3828 s->mv[0][0][1] = my;
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3829
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3830 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
3831 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
3832 } else {
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3833 s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3834 s->mv_type = MV_TYPE_8X8;
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3835 for(i=0;i<4;i++) {
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3836 mot_val = h263_pred_motion(s, i, &pred_x, &pred_y);
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3837 if (s->umvplus)
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3838 mx = h263p_decode_umotion(s, pred_x);
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3839 else
1655
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3840 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
3841 if (mx >= 0xffff)
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3842 return -1;
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3843
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3844 if (s->umvplus)
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3845 my = h263p_decode_umotion(s, pred_y);
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3846 else
1655
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3847 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
3848 if (my >= 0xffff)
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3849 return -1;
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3850 s->mv[0][i][0] = mx;
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3851 s->mv[0][i][1] = my;
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3852 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
3853 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
3854 mot_val[0] = mx;
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3855 mot_val[1] = my;
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3856 }
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3857 }
1655
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3858
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3859 if(s->obmc){
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3860 if(s->pict_type == P_TYPE && s->mb_x+1<s->mb_width)
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3861 preview_obmc(s);
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3862 }
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3863 } else if(s->pict_type==B_TYPE) {
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3864 int mb_type;
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3865 const int stride= s->b8_stride;
1701
95b7ac3344df rv20 / h263 b frame fix
michael
parents: 1680
diff changeset
3866 int16_t *mot_val0 = s->current_picture.motion_val[0][ 2*(s->mb_x + s->mb_y*stride) ];
95b7ac3344df rv20 / h263 b frame fix
michael
parents: 1680
diff changeset
3867 int16_t *mot_val1 = s->current_picture.motion_val[1][ 2*(s->mb_x + s->mb_y*stride) ];
1655
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3868 // const int mv_xy= s->mb_x + 1 + s->mb_y * s->mb_stride;
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3869
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3870 //FIXME ugly
1701
95b7ac3344df rv20 / h263 b frame fix
michael
parents: 1680
diff changeset
3871 mot_val0[0 ]= mot_val0[2 ]= mot_val0[0+2*stride]= mot_val0[2+2*stride]=
95b7ac3344df rv20 / h263 b frame fix
michael
parents: 1680
diff changeset
3872 mot_val0[1 ]= mot_val0[3 ]= mot_val0[1+2*stride]= mot_val0[3+2*stride]=
95b7ac3344df rv20 / h263 b frame fix
michael
parents: 1680
diff changeset
3873 mot_val1[0 ]= mot_val1[2 ]= mot_val1[0+2*stride]= mot_val1[2+2*stride]=
95b7ac3344df rv20 / h263 b frame fix
michael
parents: 1680
diff changeset
3874 mot_val1[1 ]= mot_val1[3 ]= mot_val1[1+2*stride]= mot_val1[3+2*stride]= 0;
1655
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3875
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3876 do{
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3877 mb_type= get_vlc2(&s->gb, h263_mbtype_b_vlc.table, H263_MBTYPE_B_VLC_BITS, 2);
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3878 if (mb_type < 0){
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3879 av_log(s->avctx, AV_LOG_ERROR, "b mb_type damaged at %d %d\n", s->mb_x, s->mb_y);
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3880 return -1;
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3881 }
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3882
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3883 mb_type= h263_mb_type_b_map[ mb_type ];
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3884 }while(!mb_type);
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3885
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3886 s->mb_intra = IS_INTRA(mb_type);
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3887 if(HAS_CBP(mb_type)){
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3888 cbpc = get_vlc2(&s->gb, cbpc_b_vlc.table, CBPC_B_VLC_BITS, 1);
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3889 if(s->mb_intra){
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3890 dquant = IS_QUANT(mb_type);
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3891 goto intra;
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3892 }
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3893
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3894 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3895
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3896 if (cbpy < 0){
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3897 av_log(s->avctx, AV_LOG_ERROR, "b cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3898 return -1;
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3899 }
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3900
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3901 if(s->alt_inter_vlc==0 || (cbpc & 3)!=3)
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3902 cbpy ^= 0xF;
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3903
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3904 cbp = (cbpc & 3) | (cbpy << 2);
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3905 }else
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3906 cbp=0;
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3907
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3908 assert(!s->mb_intra);
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3909
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3910 if(IS_QUANT(mb_type)){
1656
34b0e799aeb6 cleanup
michael
parents: 1655
diff changeset
3911 h263_decode_dquant(s);
1655
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3912 }
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3913
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3914 if(IS_DIRECT(mb_type)){
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3915 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3916 mb_type |= ff_mpeg4_set_direct_mv(s, 0, 0);
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3917 }else{
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3918 s->mv_dir = 0;
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3919 s->mv_type= MV_TYPE_16X16;
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3920 //FIXME UMV
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3921
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3922 if(USES_LIST(mb_type, 0)){
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3923 int16_t *mot_val= h263_pred_motion2(s, 0, 0, &mx, &my);
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3924 s->mv_dir = MV_DIR_FORWARD;
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3925
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3926 mx = h263_decode_motion(s, mx, 1);
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3927 my = h263_decode_motion(s, my, 1);
1701
95b7ac3344df rv20 / h263 b frame fix
michael
parents: 1680
diff changeset
3928
1655
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3929 s->mv[0][0][0] = mx;
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3930 s->mv[0][0][1] = my;
1701
95b7ac3344df rv20 / h263 b frame fix
michael
parents: 1680
diff changeset
3931 mot_val[0 ]= mot_val[2 ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx;
95b7ac3344df rv20 / h263 b frame fix
michael
parents: 1680
diff changeset
3932 mot_val[1 ]= mot_val[3 ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my;
1655
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3933 }
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3934
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3935 if(USES_LIST(mb_type, 1)){
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3936 int16_t *mot_val= h263_pred_motion2(s, 0, 1, &mx, &my);
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3937 s->mv_dir |= MV_DIR_BACKWARD;
1701
95b7ac3344df rv20 / h263 b frame fix
michael
parents: 1680
diff changeset
3938
1655
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3939 mx = h263_decode_motion(s, mx, 1);
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3940 my = h263_decode_motion(s, my, 1);
1701
95b7ac3344df rv20 / h263 b frame fix
michael
parents: 1680
diff changeset
3941
1655
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3942 s->mv[1][0][0] = mx;
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3943 s->mv[1][0][1] = my;
1701
95b7ac3344df rv20 / h263 b frame fix
michael
parents: 1680
diff changeset
3944 mot_val[0 ]= mot_val[2 ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx;
95b7ac3344df rv20 / h263 b frame fix
michael
parents: 1680
diff changeset
3945 mot_val[1 ]= mot_val[3 ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my;
1655
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3946 }
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3947 }
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3948
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
3949 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
3950 } else { /* I-Frame */
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3951 do{
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3952 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
3953 if (cbpc < 0){
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3954 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
3955 return -1;
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3956 }
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3957 }while(cbpc == 8);
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3958
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3959 dquant = cbpc & 4;
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3960 s->mb_intra = 1;
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3961 intra:
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3962 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
3963 if (s->h263_aic) {
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3964 s->ac_pred = get_bits1(&s->gb);
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3965 if(s->ac_pred){
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3966 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
3967
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3968 s->h263_aic_dir = get_bits1(&s->gb);
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3969 }
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3970 }else
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3971 s->ac_pred = 0;
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3972
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3973 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
3974 if(cbpy<0){
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3975 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
3976 return -1;
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3977 }
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3978 cbp = (cbpc & 3) | (cbpy << 2);
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3979 if (dquant) {
1656
34b0e799aeb6 cleanup
michael
parents: 1655
diff changeset
3980 h263_decode_dquant(s);
1649
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3981 }
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3982 }
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 /* decode each block */
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3985 for (i = 0; i < 6; i++) {
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3986 if (h263_decode_block(s, block[i], i, cbp&32) < 0)
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3987 return -1;
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3988 cbp+=cbp;
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3989 }
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3990 end:
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3991
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3992 /* per-MB end of slice check */
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3993 {
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3994 int v= show_bits(&s->gb, 16);
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3995
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3996 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
3997 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
3998 }
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
3999
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4000 if(v==0)
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4001 return SLICE_END;
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4002 }
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4003
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4004 return SLICE_OK;
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4005 }
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4006
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4007 int ff_mpeg4_decode_mb(MpegEncContext *s,
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4008 DCTELEM block[6][64])
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4009 {
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4010 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
4011 int16_t *mot_val;
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4012 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
4013 const int xy= s->mb_x + s->mb_y * s->mb_stride;
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4014
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4015 assert(s->h263_pred);
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4016
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4017 if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4018 do{
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4019 if (get_bits1(&s->gb)) {
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4020 /* skip mb */
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4021 s->mb_intra = 0;
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4022 for(i=0;i<6;i++)
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4023 s->block_last_index[i] = -1;
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4024 s->mv_dir = MV_DIR_FORWARD;
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4025 s->mv_type = MV_TYPE_16X16;
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4026 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4027 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
4028 s->mcsel=1;
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4029 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
4030 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
4031
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4032 s->mb_skiped = 0;
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4033 }else{
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4034 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
4035 s->mcsel=0;
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4036 s->mv[0][0][0] = 0;
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4037 s->mv[0][0][1] = 0;
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4038 s->mb_skiped = 1;
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4039 }
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4040 goto end;
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4041 }
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4042 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
4043 //fprintf(stderr, "\tCBPC: %d", cbpc);
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4044 if (cbpc < 0){
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4045 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
4046 return -1;
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4047 }
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4048 }while(cbpc == 20);
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4049
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4050 dquant = cbpc & 8;
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4051 s->mb_intra = ((cbpc & 4) != 0);
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4052 if (s->mb_intra) goto intra;
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4053
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4054 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4055 s->mcsel= get_bits1(&s->gb);
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4056 else s->mcsel= 0;
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4057 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1) ^ 0x0F;
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4058
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4059 cbp = (cbpc & 3) | (cbpy << 2);
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4060 if (dquant) {
1652
834922115010 cleanup
michael
parents: 1649
diff changeset
4061 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
4062 }
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
4063 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
4064 s->interlaced_dct= get_bits1(&s->gb);
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
4065
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4066 s->mv_dir = MV_DIR_FORWARD;
986e461dc072 Initial revision
glantau
parents:
diff changeset
4067 if ((cbpc & 16) == 0) {
619
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
4068 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
4069 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
4070 /* 16x16 global motion prediction */
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
4071 s->mv_type = MV_TYPE_16X16;
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4072 mx= get_amv(s, 0);
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
4073 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
4074 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
4075 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
4076 }else if((!s->progressive_sequence) && get_bits1(&s->gb)){
1177
fea03d2c4946 simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents: 1176
diff changeset
4077 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
4078 /* 16x8 field motion prediction */
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
4079 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
4080
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
4081 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
4082 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
4083
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
4084 h263_pred_motion(s, 0, &pred_x, &pred_y);
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
4085
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
4086 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
4087 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
4088 if (mx >= 0xffff)
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
4089 return -1;
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
4090
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
4091 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
4092 if (my >= 0xffff)
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
4093 return -1;
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
4094
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
4095 s->mv[0][i][0] = mx;
661
a0901e38c564 fixing interlaced mpeg4 decoding
michaelni
parents: 660
diff changeset
4096 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
4097 }
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
4098 }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
4099 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
4100 /* 16x16 motion prediction */
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
4101 s->mv_type = MV_TYPE_16X16;
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
4102 h263_pred_motion(s, 0, &pred_x, &pred_y);
1649
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4103 mx = h263_decode_motion(s, pred_x, s->f_code);
619
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
4104
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
4105 if (mx >= 0xffff)
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
4106 return -1;
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
4107
1649
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4108 my = h263_decode_motion(s, pred_y, s->f_code);
619
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
4109
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
4110 if (my >= 0xffff)
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
4111 return -1;
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
4112 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
4113 s->mv[0][0][1] = my;
255
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
4114 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4115 } 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
4116 s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4117 s->mv_type = MV_TYPE_8X8;
986e461dc072 Initial revision
glantau
parents:
diff changeset
4118 for(i=0;i<4;i++) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
4119 mot_val = h263_pred_motion(s, i, &pred_x, &pred_y);
1649
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4120 mx = h263_decode_motion(s, pred_x, s->f_code);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4121 if (mx >= 0xffff)
986e461dc072 Initial revision
glantau
parents:
diff changeset
4122 return -1;
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
4123
1649
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4124 my = h263_decode_motion(s, pred_y, s->f_code);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4125 if (my >= 0xffff)
986e461dc072 Initial revision
glantau
parents:
diff changeset
4126 return -1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
4127 s->mv[0][i][0] = mx;
986e461dc072 Initial revision
glantau
parents:
diff changeset
4128 s->mv[0][i][1] = my;
986e461dc072 Initial revision
glantau
parents:
diff changeset
4129 mot_val[0] = mx;
986e461dc072 Initial revision
glantau
parents:
diff changeset
4130 mot_val[1] = my;
986e461dc072 Initial revision
glantau
parents:
diff changeset
4131 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
4132 }
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
4133 } else if(s->pict_type==B_TYPE) {
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
4134 int modb1; // first bit of modb
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
4135 int modb2; // second bit of modb
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
4136 int mb_type;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
4137
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
4138 s->mb_intra = 0; //B-frames never contain intra blocks
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
4139 s->mcsel=0; // ... true gmc blocks
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
4140
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
4141 if(s->mb_x==0){
674
4490bfbb932d interlaced b frames fix
michaelni
parents: 669
diff changeset
4142 for(i=0; i<2; i++){
4490bfbb932d interlaced b frames fix
michaelni
parents: 669
diff changeset
4143 s->last_mv[i][0][0]=
4490bfbb932d interlaced b frames fix
michaelni
parents: 669
diff changeset
4144 s->last_mv[i][0][1]=
4490bfbb932d interlaced b frames fix
michaelni
parents: 669
diff changeset
4145 s->last_mv[i][1][0]=
4490bfbb932d interlaced b frames fix
michaelni
parents: 669
diff changeset
4146 s->last_mv[i][1][1]= 0;
4490bfbb932d interlaced b frames fix
michaelni
parents: 669
diff changeset
4147 }
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
4148 }
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
4149
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
4150 /* if we skipped it in the future P Frame than skip it now too */
1177
fea03d2c4946 simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents: 1176
diff changeset
4151 s->mb_skiped= s->next_picture.mbskip_table[s->mb_y * s->mb_stride + s->mb_x]; // Note, skiptab=0 if last was GMC
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
4152
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
4153 if(s->mb_skiped){
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
4154 /* skip mb */
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
4155 for(i=0;i<6;i++)
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
4156 s->block_last_index[i] = -1;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
4157
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
4158 s->mv_dir = MV_DIR_FORWARD;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
4159 s->mv_type = MV_TYPE_16X16;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
4160 s->mv[0][0][0] = 0;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
4161 s->mv[0][0][1] = 0;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
4162 s->mv[1][0][0] = 0;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
4163 s->mv[1][0][1] = 0;
1177
fea03d2c4946 simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents: 1176
diff changeset
4164 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
4165 goto end;
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
4166 }
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
4167
666
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
4168 modb1= get_bits1(&s->gb);
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
4169 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
4170 mb_type= MB_TYPE_DIRECT2 | MB_TYPE_SKIP | MB_TYPE_L0L1; //like MB_TYPE_B_DIRECT but no vectors coded
666
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
4171 cbp=0;
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
4172 }else{
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
4173 modb2= get_bits1(&s->gb);
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
4174 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
4175 if(mb_type<0){
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1586
diff changeset
4176 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
4177 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
4178 }
fea03d2c4946 simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents: 1176
diff changeset
4179 mb_type= mb_type_b_map[ mb_type ];
666
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
4180 if(modb2) cbp= 0;
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
4181 else cbp= get_bits(&s->gb, 6);
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
4182
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
4183 if ((!IS_DIRECT(mb_type)) && cbp) {
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
4184 if(get_bits1(&s->gb)){
1652
834922115010 cleanup
michael
parents: 1649
diff changeset
4185 ff_set_qscale(s, s->qscale + get_bits1(&s->gb)*4 - 2);
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
4186 }
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
4187 }
664
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
4188
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
4189 if(!s->progressive_sequence){
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
4190 if(cbp)
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
4191 s->interlaced_dct= get_bits1(&s->gb);
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
4192
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
4193 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
4194 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
4195 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
4196
fea03d2c4946 simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents: 1176
diff changeset
4197 if(USES_LIST(mb_type, 0)){
667
5446a41a00fe 10l (field select readed at the wrong place ...)
michaelni
parents: 666
diff changeset
4198 s->field_select[0][0]= get_bits1(&s->gb);
5446a41a00fe 10l (field select readed at the wrong place ...)
michaelni
parents: 666
diff changeset
4199 s->field_select[0][1]= get_bits1(&s->gb);
5446a41a00fe 10l (field select readed at the wrong place ...)
michaelni
parents: 666
diff changeset
4200 }
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
4201 if(USES_LIST(mb_type, 1)){
667
5446a41a00fe 10l (field select readed at the wrong place ...)
michaelni
parents: 666
diff changeset
4202 s->field_select[1][0]= get_bits1(&s->gb);
5446a41a00fe 10l (field select readed at the wrong place ...)
michaelni
parents: 666
diff changeset
4203 s->field_select[1][1]= get_bits1(&s->gb);
5446a41a00fe 10l (field select readed at the wrong place ...)
michaelni
parents: 666
diff changeset
4204 }
5446a41a00fe 10l (field select readed at the wrong place ...)
michaelni
parents: 666
diff changeset
4205 }
666
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
4206 }
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
4207
667
5446a41a00fe 10l (field select readed at the wrong place ...)
michaelni
parents: 666
diff changeset
4208 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
4209 if((mb_type & (MB_TYPE_DIRECT2|MB_TYPE_INTERLACED)) == 0){
666
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
4210 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
4211
fea03d2c4946 simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents: 1176
diff changeset
4212 if(USES_LIST(mb_type, 0)){
666
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
4213 s->mv_dir = MV_DIR_FORWARD;
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
4214
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
4215 mx = h263_decode_motion(s, s->last_mv[0][0][0], s->f_code);
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
4216 my = h263_decode_motion(s, s->last_mv[0][0][1], s->f_code);
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
4217 s->last_mv[0][1][0]= s->last_mv[0][0][0]= s->mv[0][0][0] = mx;
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
4218 s->last_mv[0][1][1]= s->last_mv[0][0][1]= s->mv[0][0][1] = my;
667
5446a41a00fe 10l (field select readed at the wrong place ...)
michaelni
parents: 666
diff changeset
4219 }
666
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
4220
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
4221 if(USES_LIST(mb_type, 1)){
666
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
4222 s->mv_dir |= MV_DIR_BACKWARD;
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
4223
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
4224 mx = h263_decode_motion(s, s->last_mv[1][0][0], s->b_code);
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
4225 my = h263_decode_motion(s, s->last_mv[1][0][1], s->b_code);
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
4226 s->last_mv[1][1][0]= s->last_mv[1][0][0]= s->mv[1][0][0] = mx;
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
4227 s->last_mv[1][1][1]= s->last_mv[1][0][1]= s->mv[1][0][1] = my;
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
4228 }
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
4229 }else if(!IS_DIRECT(mb_type)){
666
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
4230 s->mv_type= MV_TYPE_FIELD;
667
5446a41a00fe 10l (field select readed at the wrong place ...)
michaelni
parents: 666
diff changeset
4231
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
4232 if(USES_LIST(mb_type, 0)){
666
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
4233 s->mv_dir = MV_DIR_FORWARD;
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
4234
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
4235 for(i=0; i<2; i++){
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
4236 mx = h263_decode_motion(s, s->last_mv[0][i][0] , s->f_code);
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
4237 my = h263_decode_motion(s, s->last_mv[0][i][1]/2, s->f_code);
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
4238 s->last_mv[0][i][0]= s->mv[0][i][0] = mx;
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
4239 s->last_mv[0][i][1]= (s->mv[0][i][1] = my)*2;
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
4240 }
667
5446a41a00fe 10l (field select readed at the wrong place ...)
michaelni
parents: 666
diff changeset
4241 }
666
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
4242
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
4243 if(USES_LIST(mb_type, 1)){
666
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
4244 s->mv_dir |= MV_DIR_BACKWARD;
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
4245
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
4246 for(i=0; i<2; i++){
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
4247 mx = h263_decode_motion(s, s->last_mv[1][i][0] , s->b_code);
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
4248 my = h263_decode_motion(s, s->last_mv[1][i][1]/2, s->b_code);
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
4249 s->last_mv[1][i][0]= s->mv[1][i][0] = mx;
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
4250 s->last_mv[1][i][1]= (s->mv[1][i][1] = my)*2;
664
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
4251 }
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
4252 }
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
4253 }
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
4254 }
666
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
4255
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
4256 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
4257 if(IS_SKIP(mb_type))
666
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
4258 mx=my=0;
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
4259 else{
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
4260 mx = h263_decode_motion(s, 0, 1);
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
4261 my = h263_decode_motion(s, 0, 1);
f5b8b5dd50d7 interlaced b frames cleanup
michaelni
parents: 664
diff changeset
4262 }
664
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
4263
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
4264 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
4265 mb_type |= ff_mpeg4_set_direct_mv(s, mx, my);
664
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
4266 }
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
4267 s->current_picture.mb_type[xy]= mb_type;
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
4268 } else { /* I-Frame */
1482
b372ecde32a8 h263 stuffing decode fix
michaelni
parents: 1457
diff changeset
4269 do{
b372ecde32a8 h263 stuffing decode fix
michaelni
parents: 1457
diff changeset
4270 cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
b372ecde32a8 h263 stuffing decode fix
michaelni
parents: 1457
diff changeset
4271 if (cbpc < 0){
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1586
diff changeset
4272 av_log(s->avctx, AV_LOG_ERROR, "I cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
1482
b372ecde32a8 h263 stuffing decode fix
michaelni
parents: 1457
diff changeset
4273 return -1;
b372ecde32a8 h263 stuffing decode fix
michaelni
parents: 1457
diff changeset
4274 }
b372ecde32a8 h263 stuffing decode fix
michaelni
parents: 1457
diff changeset
4275 }while(cbpc == 8);
b372ecde32a8 h263 stuffing decode fix
michaelni
parents: 1457
diff changeset
4276
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
4277 dquant = cbpc & 4;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
4278 s->mb_intra = 1;
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
4279 intra:
1649
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4280 s->ac_pred = get_bits1(&s->gb);
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4281 if(s->ac_pred)
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4282 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
4283 else
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4284 s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
591
d3f374218030 fixing mpeg4 mpeg quantizers
michaelni
parents: 582
diff changeset
4285
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
4286 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
1482
b372ecde32a8 h263 stuffing decode fix
michaelni
parents: 1457
diff changeset
4287 if(cbpy<0){
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1586
diff changeset
4288 av_log(s->avctx, AV_LOG_ERROR, "I cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
1482
b372ecde32a8 h263 stuffing decode fix
michaelni
parents: 1457
diff changeset
4289 return -1;
b372ecde32a8 h263 stuffing decode fix
michaelni
parents: 1457
diff changeset
4290 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4291 cbp = (cbpc & 3) | (cbpy << 2);
986e461dc072 Initial revision
glantau
parents:
diff changeset
4292 if (dquant) {
1652
834922115010 cleanup
michael
parents: 1649
diff changeset
4293 ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4294 }
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
4295
619
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
4296 if(!s->progressive_sequence)
2be2cc8fd0a1 mpeg4 interlaced decoding support (not completly implemented/tested due to lack of samples)
michaelni
parents: 617
diff changeset
4297 s->interlaced_dct= get_bits1(&s->gb);
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
4298
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
4299 /* decode each block */
1649
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4300 for (i = 0; i < 6; i++) {
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4301 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
4302 return -1;
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4303 cbp+=cbp;
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
4304 }
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
4305 goto end;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4306 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
4307
986e461dc072 Initial revision
glantau
parents:
diff changeset
4308 /* decode each block */
1649
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4309 for (i = 0; i < 6; i++) {
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4310 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
4311 return -1;
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
4312 cbp+=cbp;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4313 }
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
4314 end:
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
4315
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
4316 /* per-MB end of slice check */
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
4317 if(s->codec_id==CODEC_ID_MPEG4){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
4318 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
4319 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
4320 if(s->pict_type==B_TYPE && s->next_picture.mbskip_table[xy + delta])
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
4321 return SLICE_OK;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
4322 return SLICE_END;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
4323 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
4324 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
4325
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
4326 return SLICE_OK;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4327 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
4328
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
4329 static int h263_decode_motion(MpegEncContext * s, int pred, int f_code)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4330 {
656
e47fa3e3f2d5 statistics for forw & back p-MBs instead of just one counter for both
michaelni
parents: 654
diff changeset
4331 int code, val, sign, shift, l;
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
4332 code = get_vlc2(&s->gb, mv_vlc.table, MV_VLC_BITS, 2);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4333
986e461dc072 Initial revision
glantau
parents:
diff changeset
4334 if (code == 0)
986e461dc072 Initial revision
glantau
parents:
diff changeset
4335 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
4336 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
4337 return 0xffff;
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
4338
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
4339 sign = get_bits1(&s->gb);
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
4340 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
4341 val = code;
625ccacd1113 decode motion & modulo optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents: 1254
diff changeset
4342 if (shift) {
625ccacd1113 decode motion & modulo optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents: 1254
diff changeset
4343 val = (val - 1) << shift;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4344 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
4345 val++;
625ccacd1113 decode motion & modulo optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents: 1254
diff changeset
4346 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4347 if (sign)
986e461dc072 Initial revision
glantau
parents:
diff changeset
4348 val = -val;
986e461dc072 Initial revision
glantau
parents:
diff changeset
4349 val += pred;
475
6ccc48e4c41b run1 can be <0 bugfix (found by fabrice)
michaelni
parents: 469
diff changeset
4350
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4351 /* modulo decoding */
986e461dc072 Initial revision
glantau
parents:
diff changeset
4352 if (!s->h263_long_vectors) {
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
4353 l = 1 << (f_code + 4);
1255
625ccacd1113 decode motion & modulo optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents: 1254
diff changeset
4354 val = ((val + l)&(l*2-1)) - l;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4355 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
4356 /* horrible h263 long vector mode */
986e461dc072 Initial revision
glantau
parents:
diff changeset
4357 if (pred < -31 && val < -63)
986e461dc072 Initial revision
glantau
parents:
diff changeset
4358 val += 64;
986e461dc072 Initial revision
glantau
parents:
diff changeset
4359 if (pred > 32 && val > 63)
986e461dc072 Initial revision
glantau
parents:
diff changeset
4360 val -= 64;
154
f914f710b8d0 - Fixed a bug on H.263 MV prediction for MB on GOBs limits.
pulento
parents: 144
diff changeset
4361
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4362 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
4363 return val;
986e461dc072 Initial revision
glantau
parents:
diff changeset
4364 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
4365
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
4366 /* Decodes RVLC of H.263+ UMV */
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
4367 static int h263p_decode_umotion(MpegEncContext * s, int pred)
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
4368 {
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
4369 int code = 0, sign;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
4370
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
4371 if (get_bits1(&s->gb)) /* Motion difference = 0 */
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
4372 return pred;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
4373
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
4374 code = 2 + get_bits1(&s->gb);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
4375
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
4376 while (get_bits1(&s->gb))
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
4377 {
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
4378 code <<= 1;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
4379 code += get_bits1(&s->gb);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
4380 }
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
4381 sign = code & 1;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
4382 code >>= 1;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
4383
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
4384 code = (sign) ? (pred - code) : (pred + code);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
4385 #ifdef DEBUG
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
4386 fprintf(stderr,"H.263+ UMV Motion = %d\n", code);
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
4387 #endif
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
4388 return code;
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
4389
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
4390 }
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
4391
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4392 static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
986e461dc072 Initial revision
glantau
parents:
diff changeset
4393 int n, int coded)
986e461dc072 Initial revision
glantau
parents:
diff changeset
4394 {
986e461dc072 Initial revision
glantau
parents:
diff changeset
4395 int code, level, i, j, last, run;
986e461dc072 Initial revision
glantau
parents:
diff changeset
4396 RLTable *rl = &rl_inter;
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
4397 const uint8_t *scan_table;
1637
7799582dc9b8 h263 alternative inter vlc support
michael
parents: 1633
diff changeset
4398 GetBitContext gb= s->gb;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4399
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
4400 scan_table = s->intra_scantable.permutated;
249
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
4401 if (s->h263_aic && s->mb_intra) {
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
4402 rl = &rl_intra_aic;
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
4403 i = 0;
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
4404 if (s->ac_pred) {
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
4405 if (s->h263_aic_dir)
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
4406 scan_table = s->intra_v_scantable.permutated; /* left */
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
4407 else
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
4408 scan_table = s->intra_h_scantable.permutated; /* top */
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
4409 }
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
4410 } else if (s->mb_intra) {
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
4411 /* DC coef */
1641
0226cad80fc2 cleanup
michael
parents: 1639
diff changeset
4412 if(s->codec_id == CODEC_ID_RV10){
1090
michaelni
parents: 1089
diff changeset
4413 if (s->rv10_version == 3 && s->pict_type == I_TYPE) {
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4414 int component, diff;
986e461dc072 Initial revision
glantau
parents:
diff changeset
4415 component = (n <= 3 ? 0 : n - 4 + 1);
986e461dc072 Initial revision
glantau
parents:
diff changeset
4416 level = s->last_dc[component];
986e461dc072 Initial revision
glantau
parents:
diff changeset
4417 if (s->rv10_first_dc_coded[component]) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
4418 diff = rv_decode_dc(s, n);
986e461dc072 Initial revision
glantau
parents:
diff changeset
4419 if (diff == 0xffff)
986e461dc072 Initial revision
glantau
parents:
diff changeset
4420 return -1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
4421 level += diff;
986e461dc072 Initial revision
glantau
parents:
diff changeset
4422 level = level & 0xff; /* handle wrap round */
986e461dc072 Initial revision
glantau
parents:
diff changeset
4423 s->last_dc[component] = level;
986e461dc072 Initial revision
glantau
parents:
diff changeset
4424 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
4425 s->rv10_first_dc_coded[component] = 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
4426 }
1090
michaelni
parents: 1089
diff changeset
4427 } else {
michaelni
parents: 1089
diff changeset
4428 level = get_bits(&s->gb, 8);
michaelni
parents: 1089
diff changeset
4429 }
michaelni
parents: 1089
diff changeset
4430 }else{
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4431 level = get_bits(&s->gb, 8);
1089
7e79a58954b1 h263(+) clenaup & bugfixes
michaelni
parents: 1070
diff changeset
4432 if((level&0x7F) == 0){
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1586
diff changeset
4433 av_log(s->avctx, AV_LOG_ERROR, "illegal dc %d at %d %d\n", level, s->mb_x, s->mb_y);
1089
7e79a58954b1 h263(+) clenaup & bugfixes
michaelni
parents: 1070
diff changeset
4434 return -1;
7e79a58954b1 h263(+) clenaup & bugfixes
michaelni
parents: 1070
diff changeset
4435 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4436 if (level == 255)
986e461dc072 Initial revision
glantau
parents:
diff changeset
4437 level = 128;
986e461dc072 Initial revision
glantau
parents:
diff changeset
4438 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
4439 block[0] = level;
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
4440 i = 1;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4441 } else {
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
4442 i = 0;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4443 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
4444 if (!coded) {
249
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
4445 if (s->mb_intra && s->h263_aic)
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
4446 goto not_coded;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4447 s->block_last_index[n] = i - 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
4448 return 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
4449 }
1637
7799582dc9b8 h263 alternative inter vlc support
michael
parents: 1633
diff changeset
4450 retry:
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4451 for(;;) {
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
4452 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
4453 if (code < 0){
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1586
diff changeset
4454 av_log(s->avctx, AV_LOG_ERROR, "illegal ac vlc code at %dx%d\n", s->mb_x, s->mb_y);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4455 return -1;
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
4456 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4457 if (code == rl->n) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
4458 /* escape */
1353
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
4459 if (s->h263_flv > 1) {
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
4460 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
4461 last = get_bits1(&s->gb);
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
4462 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
4463 if(is11){
1356
9e31b6bfb1a2 fix? flv escape codes
michaelni
parents: 1354
diff changeset
4464 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
4465 } else {
1356
9e31b6bfb1a2 fix? flv escape codes
michaelni
parents: 1354
diff changeset
4466 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
4467 }
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
4468 } else {
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
4469 last = get_bits1(&s->gb);
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
4470 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
4471 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
4472 if(level == -128){
1641
0226cad80fc2 cleanup
michael
parents: 1639
diff changeset
4473 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
4474 /* XXX: should patch encoder too */
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
4475 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
4476 }else{
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
4477 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
4478 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
4479 }
1089
7e79a58954b1 h263(+) clenaup & bugfixes
michaelni
parents: 1070
diff changeset
4480 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4481 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
4482 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
4483 run = rl->table_run[code];
986e461dc072 Initial revision
glantau
parents:
diff changeset
4484 level = rl->table_level[code];
986e461dc072 Initial revision
glantau
parents:
diff changeset
4485 last = code >= rl->last;
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
4486 if (get_bits1(&s->gb))
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4487 level = -level;
986e461dc072 Initial revision
glantau
parents:
diff changeset
4488 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
4489 i += run;
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
4490 if (i >= 64){
1637
7799582dc9b8 h263 alternative inter vlc support
michael
parents: 1633
diff changeset
4491 if(s->alt_inter_vlc && rl == &rl_inter && !s->mb_intra){
7799582dc9b8 h263 alternative inter vlc support
michael
parents: 1633
diff changeset
4492 //looks like a hack but no, its the way its supposed to work ...
7799582dc9b8 h263 alternative inter vlc support
michael
parents: 1633
diff changeset
4493 rl = &rl_intra_aic;
7799582dc9b8 h263 alternative inter vlc support
michael
parents: 1633
diff changeset
4494 i = 0;
7799582dc9b8 h263 alternative inter vlc support
michael
parents: 1633
diff changeset
4495 s->gb= gb;
7799582dc9b8 h263 alternative inter vlc support
michael
parents: 1633
diff changeset
4496 memset(block, 0, sizeof(DCTELEM)*64);
7799582dc9b8 h263 alternative inter vlc support
michael
parents: 1633
diff changeset
4497 goto retry;
7799582dc9b8 h263 alternative inter vlc support
michael
parents: 1633
diff changeset
4498 }
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1586
diff changeset
4499 av_log(s->avctx, AV_LOG_ERROR, "run overflow at %dx%d\n", s->mb_x, s->mb_y);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4500 return -1;
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
4501 }
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
4502 j = scan_table[i];
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4503 block[j] = level;
986e461dc072 Initial revision
glantau
parents:
diff changeset
4504 if (last)
986e461dc072 Initial revision
glantau
parents:
diff changeset
4505 break;
986e461dc072 Initial revision
glantau
parents:
diff changeset
4506 i++;
986e461dc072 Initial revision
glantau
parents:
diff changeset
4507 }
249
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
4508 not_coded:
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
4509 if (s->mb_intra && s->h263_aic) {
42a0b7b16738 - Bug fixes in H.263+ Advanced INTRA Coding decoder.
pulento
parents: 248
diff changeset
4510 h263_pred_acdc(s, block, n);
265
4e9e728021d8 use ac prediction in mpeg4 encoding (5% smaller intra-blocks/keyframes)
michaelni
parents: 264
diff changeset
4511 i = 63;
248
56ee684c48bb - H.263+ decoder support for Advanded INTRA Coding (buggy)
pulento
parents: 245
diff changeset
4512 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4513 s->block_last_index[n] = i;
986e461dc072 Initial revision
glantau
parents:
diff changeset
4514 return 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
4515 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
4516
1034
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
4517 /**
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
4518 * decodes the dc value.
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
4519 * @param n block index (0-3 are luma, 4-5 are chroma)
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
4520 * @param dir_ptr the prediction direction will be stored here
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
4521 * @return the quantized dc
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
4522 */
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
4523 static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4524 {
986e461dc072 Initial revision
glantau
parents:
diff changeset
4525 int level, pred, code;
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
4526 uint16_t *dc_val;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4527
986e461dc072 Initial revision
glantau
parents:
diff changeset
4528 if (n < 4)
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
4529 code = get_vlc2(&s->gb, dc_lum.table, DC_VLC_BITS, 1);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4530 else
544
5264fb104700 optimization (get_vlc -> get_vlc2)
michaelni
parents: 542
diff changeset
4531 code = get_vlc2(&s->gb, dc_chrom.table, DC_VLC_BITS, 1);
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
4532 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
4533 av_log(s->avctx, AV_LOG_ERROR, "illegal dc vlc\n");
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4534 return -1;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
4535 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4536 if (code == 0) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
4537 level = 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
4538 } 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
4539 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
4540 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
4541 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
4542 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
4543 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
4544 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
4545 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
4546 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
4547 }
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
4548 }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
4549 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
4550 }
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
4551
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
4552 if (code > 8){
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
4553 if(get_bits1(&s->gb)==0){ /* marker */
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
4554 if(s->error_resilience>=2){
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1586
diff changeset
4555 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
4556 return -1;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
4557 }
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
4558 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
4559 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4560 }
498
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
4561 pred = ff_mpeg4_pred_dc(s, n, &dc_val, dir_ptr);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4562 level += pred;
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
4563 if (level < 0){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
4564 if(s->error_resilience>=3){
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1586
diff changeset
4565 av_log(s->avctx, AV_LOG_ERROR, "dc<0 at %dx%d\n", s->mb_x, s->mb_y);
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
4566 return -1;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
4567 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4568 level = 0;
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
4569 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4570 if (n < 4) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
4571 *dc_val = level * s->y_dc_scale;
986e461dc072 Initial revision
glantau
parents:
diff changeset
4572 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
4573 *dc_val = level * s->c_dc_scale;
986e461dc072 Initial revision
glantau
parents:
diff changeset
4574 }
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
4575 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
4576 *dc_val = level * 8;
42ea05e4a391 improving 3IV1 support (still far from perfect) note, disabled as it requires some checks in the inner loops which would slow things down a tiny bit
michaelni
parents: 1261
diff changeset
4577
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
4578 if(s->error_resilience>=3){
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
4579 if(*dc_val > 2048 + s->y_dc_scale + s->c_dc_scale){
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1586
diff changeset
4580 av_log(s->avctx, AV_LOG_ERROR, "dc overflow at %dx%d\n", s->mb_x, s->mb_y);
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
4581 return -1;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
4582 }
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
4583 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4584 return level;
986e461dc072 Initial revision
glantau
parents:
diff changeset
4585 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
4586
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
4587 /**
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
4588 * decodes a block.
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
4589 * @return <0 if an error occured
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
4590 */
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
4591 static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
1132
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
4592 int n, int coded, int intra, int rvlc)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4593 {
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4594 int level, i, last, run;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4595 int dc_pred_dir;
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
4596 RLTable * rl;
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
4597 RL_VLC_ELEM * rl_vlc;
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1057
diff changeset
4598 const uint8_t * scan_table;
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4599 int qmul, qadd;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4600
1132
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
4601 //Note intra & rvlc should be optimized away if this is inlined
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
4602
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
4603 if(intra) {
1520
ad5461bad820 intra dc treshold != 0 decoding fixed
michael
parents: 1512
diff changeset
4604 if(s->qscale < s->intra_dc_threshold){
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4605 /* DC coef */
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
4606 if(s->partitioned_frame){
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
4607 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
4608 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
4609 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
4610 dc_pred_dir= (s->pred_dir_table[s->mb_x + s->mb_y*s->mb_stride]<<n)&32;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
4611 }else{
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
4612 level = mpeg4_decode_dc(s, n, &dc_pred_dir);
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
4613 if (level < 0)
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
4614 return -1;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
4615 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4616 block[0] = level;
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4617 i = 0;
1520
ad5461bad820 intra dc treshold != 0 decoding fixed
michael
parents: 1512
diff changeset
4618 }else{
ad5461bad820 intra dc treshold != 0 decoding fixed
michael
parents: 1512
diff changeset
4619 i = -1;
ad5461bad820 intra dc treshold != 0 decoding fixed
michael
parents: 1512
diff changeset
4620 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4621 if (!coded)
986e461dc072 Initial revision
glantau
parents:
diff changeset
4622 goto not_coded;
1132
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
4623
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
4624 if(rvlc){
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
4625 rl = &rvlc_rl_intra;
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
4626 rl_vlc = rvlc_rl_intra.rl_vlc[0];
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
4627 }else{
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
4628 rl = &rl_intra;
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
4629 rl_vlc = rl_intra.rl_vlc[0];
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
4630 }
718
16dab8296293 fixing custom quantizer matrix decoding
michaelni
parents: 706
diff changeset
4631 if (s->ac_pred) {
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4632 if (dc_pred_dir == 0)
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
4633 scan_table = s->intra_v_scantable.permutated; /* left */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4634 else
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
4635 scan_table = s->intra_h_scantable.permutated; /* top */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4636 } else {
706
e65798d228ea idct permutation cleanup, idct can be selected per context now
michaelni
parents: 702
diff changeset
4637 scan_table = s->intra_scantable.permutated;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4638 }
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4639 qmul=1;
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4640 qadd=0;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4641 } else {
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4642 i = -1;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4643 if (!coded) {
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4644 s->block_last_index[n] = i;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4645 return 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
4646 }
1132
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
4647 if(rvlc) rl = &rvlc_rl_inter;
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
4648 else rl = &rl_inter;
661
a0901e38c564 fixing interlaced mpeg4 decoding
michaelni
parents: 660
diff changeset
4649
718
16dab8296293 fixing custom quantizer matrix decoding
michaelni
parents: 706
diff changeset
4650 scan_table = s->intra_scantable.permutated;
661
a0901e38c564 fixing interlaced mpeg4 decoding
michaelni
parents: 660
diff changeset
4651
591
d3f374218030 fixing mpeg4 mpeg quantizers
michaelni
parents: 582
diff changeset
4652 if(s->mpeg_quant){
d3f374218030 fixing mpeg4 mpeg quantizers
michaelni
parents: 582
diff changeset
4653 qmul=1;
d3f374218030 fixing mpeg4 mpeg quantizers
michaelni
parents: 582
diff changeset
4654 qadd=0;
1132
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
4655 if(rvlc){
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
4656 rl_vlc = rvlc_rl_inter.rl_vlc[0];
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
4657 }else{
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
4658 rl_vlc = rl_inter.rl_vlc[0];
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
4659 }
591
d3f374218030 fixing mpeg4 mpeg quantizers
michaelni
parents: 582
diff changeset
4660 }else{
d3f374218030 fixing mpeg4 mpeg quantizers
michaelni
parents: 582
diff changeset
4661 qmul = s->qscale << 1;
d3f374218030 fixing mpeg4 mpeg quantizers
michaelni
parents: 582
diff changeset
4662 qadd = (s->qscale - 1) | 1;
1132
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
4663 if(rvlc){
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
4664 rl_vlc = rvlc_rl_inter.rl_vlc[s->qscale];
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
4665 }else{
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
4666 rl_vlc = rl_inter.rl_vlc[s->qscale];
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
4667 }
591
d3f374218030 fixing mpeg4 mpeg quantizers
michaelni
parents: 582
diff changeset
4668 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4669 }
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4670 {
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4671 OPEN_READER(re, &s->gb);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4672 for(;;) {
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4673 UPDATE_CACHE(re, &s->gb);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4674 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4675 if (level==0) {
1132
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
4676 /* escape */
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
4677 if(rvlc){
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
4678 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
4679 av_log(s->avctx, AV_LOG_ERROR, "1. marker bit missing in rvlc esc\n");
1132
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
4680 return -1;
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
4681 }; SKIP_CACHE(re, &s->gb, 1);
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
4682
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
4683 last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
4684 run= SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6);
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
4685 SKIP_COUNTER(re, &s->gb, 1+1+6);
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
4686 UPDATE_CACHE(re, &s->gb);
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
4687
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
4688 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
4689 av_log(s->avctx, AV_LOG_ERROR, "2. marker bit missing in rvlc esc\n");
1132
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
4690 return -1;
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
4691 }; SKIP_CACHE(re, &s->gb, 1);
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
4692
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
4693 level= SHOW_UBITS(re, &s->gb, 11); SKIP_CACHE(re, &s->gb, 11);
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
4694
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
4695 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
4696 av_log(s->avctx, AV_LOG_ERROR, "reverse esc missing\n");
1132
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
4697 return -1;
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
4698 }; SKIP_CACHE(re, &s->gb, 5);
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
4699
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
4700 level= level * qmul + qadd;
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
4701 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); LAST_SKIP_CACHE(re, &s->gb, 1);
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
4702 SKIP_COUNTER(re, &s->gb, 1+11+5+1);
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
4703
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
4704 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
4705 if(last) i+=192;
1132
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
4706 }else{
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4707 int cache;
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4708 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
4709
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
4710 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
4711 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
4712
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4713 if (cache&0x80000000) {
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4714 if (cache&0x40000000) {
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4715 /* third escape */
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4716 SKIP_CACHE(re, &s->gb, 2);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4717 last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4718 run= SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4719 SKIP_COUNTER(re, &s->gb, 2+1+6);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4720 UPDATE_CACHE(re, &s->gb);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4721
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
4722 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
4723 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
4724 }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
4725 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
4726 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
4727 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
4728 }; 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
4729
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
4730 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
4731
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
4732 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
4733 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
4734 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
4735 }; 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
4736
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
4737 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
4738 }
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4739
597
d5d0c11ea4cf fixing level overflow check for qp=1
michaelni
parents: 591
diff changeset
4740 if(level*s->qscale>1024 || level*s->qscale<-1024){
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1586
diff changeset
4741 av_log(s->avctx, AV_LOG_ERROR, "|level| overflow in 3. esc, qp=%d\n", s->qscale);
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
4742 return -1;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
4743 }
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
4744 #if 0
39efe24058ad dont check if the ac esc 3 could have been stored as vlc as this detects only very few errors allthough it detects several buggy encoders
michael
parents: 1522
diff changeset
4745 if(s->error_resilience >= FF_ER_COMPLIANT){
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
4746 const int abs_level= ABS(level);
1525
39efe24058ad dont check if the ac esc 3 could have been stored as vlc as this detects only very few errors allthough it detects several buggy encoders
michael
parents: 1522
diff changeset
4747 if(abs_level<=MAX_LEVEL && run<=MAX_RUN){
498
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
4748 const int run1= run - rl->max_run[last][abs_level] - 1;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
4749 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
4750 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
4751 return -1;
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
4752 }
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
4753 if(s->error_resilience > FF_ER_COMPLIANT){
2b93dc762f9a fixing illegal 3. esc bug (the mpeg4 std only requires encoders to use unescaped symbols but not esc1 or esc2 if they are shorter than esc3, andjust beause its logical to use the shortest possible vlc doesnt mean encoders do that)
michaelni
parents: 903
diff changeset
4754 if(abs_level <= rl->max_level[last][run]*2){
2b93dc762f9a fixing illegal 3. esc bug (the mpeg4 std only requires encoders to use unescaped symbols but not esc1 or esc2 if they are shorter than esc3, andjust beause its logical to use the shortest possible vlc doesnt mean encoders do that)
michaelni
parents: 903
diff changeset
4755 fprintf(stderr, "illegal 3. esc, esc 1 encoding possible\n");
2b93dc762f9a fixing illegal 3. esc bug (the mpeg4 std only requires encoders to use unescaped symbols but not esc1 or esc2 if they are shorter than esc3, andjust beause its logical to use the shortest possible vlc doesnt mean encoders do that)
michaelni
parents: 903
diff changeset
4756 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
4757 }
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
4758 if(run1 >= 0 && abs_level <= rl->max_level[last][run1]){
2b93dc762f9a fixing illegal 3. esc bug (the mpeg4 std only requires encoders to use unescaped symbols but not esc1 or esc2 if they are shorter than esc3, andjust beause its logical to use the shortest possible vlc doesnt mean encoders do that)
michaelni
parents: 903
diff changeset
4759 fprintf(stderr, "illegal 3. esc, esc 2 encoding possible\n");
2b93dc762f9a fixing illegal 3. esc bug (the mpeg4 std only requires encoders to use unescaped symbols but not esc1 or esc2 if they are shorter than esc3, andjust beause its logical to use the shortest possible vlc doesnt mean encoders do that)
michaelni
parents: 903
diff changeset
4760 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
4761 }
453
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
4762 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
4763 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
4764 }
69876443a723 error concealment / error resilience
michaelni
parents: 429
diff changeset
4765 #endif
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4766 if (level>0) level= level * qmul + qadd;
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4767 else level= level * qmul - qadd;
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4768
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4769 i+= run + 1;
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4770 if(last) i+=192;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4771 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
4772 /* second escape */
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4773 #if MIN_CACHE_BITS < 20
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4774 LAST_SKIP_BITS(re, &s->gb, 2);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4775 UPDATE_CACHE(re, &s->gb);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4776 #else
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4777 SKIP_BITS(re, &s->gb, 2);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4778 #endif
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4779 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4780 i+= run + rl->max_run[run>>7][level/qmul] +1; //FIXME opt indexing
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4781 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4782 LAST_SKIP_BITS(re, &s->gb, 1);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4783 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
4784 } else {
986e461dc072 Initial revision
glantau
parents:
diff changeset
4785 /* first escape */
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4786 #if MIN_CACHE_BITS < 19
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4787 LAST_SKIP_BITS(re, &s->gb, 1);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4788 UPDATE_CACHE(re, &s->gb);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4789 #else
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4790 SKIP_BITS(re, &s->gb, 1);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4791 #endif
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4792 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4793 i+= run;
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4794 level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//FIXME opt indexing
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4795 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4796 LAST_SKIP_BITS(re, &s->gb, 1);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4797 }
1132
61c89e8ffa88 rvlc decoding support
michaelni
parents: 1126
diff changeset
4798 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4799 } else {
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4800 i+= run;
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4801 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4802 LAST_SKIP_BITS(re, &s->gb, 1);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4803 }
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4804 if (i > 62){
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4805 i-= 192;
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4806 if(i&(~63)){
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1586
diff changeset
4807 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
4808 return -1;
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4809 }
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4810
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4811 block[scan_table[i]] = level;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4812 break;
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4813 }
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4814
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4815 block[scan_table[i]] = level;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4816 }
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4817 CLOSE_READER(re, &s->gb);
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4818 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4819 not_coded:
1520
ad5461bad820 intra dc treshold != 0 decoding fixed
michael
parents: 1512
diff changeset
4820 if (intra) {
ad5461bad820 intra dc treshold != 0 decoding fixed
michael
parents: 1512
diff changeset
4821 if(s->qscale >= s->intra_dc_threshold){
ad5461bad820 intra dc treshold != 0 decoding fixed
michael
parents: 1512
diff changeset
4822 uint16_t *dc_val;
ad5461bad820 intra dc treshold != 0 decoding fixed
michael
parents: 1512
diff changeset
4823 block[0] += ff_mpeg4_pred_dc(s, n, &dc_val, &dc_pred_dir);
ad5461bad820 intra dc treshold != 0 decoding fixed
michael
parents: 1512
diff changeset
4824 if (n < 4) {
ad5461bad820 intra dc treshold != 0 decoding fixed
michael
parents: 1512
diff changeset
4825 *dc_val = block[0] * s->y_dc_scale;
ad5461bad820 intra dc treshold != 0 decoding fixed
michael
parents: 1512
diff changeset
4826 } else {
ad5461bad820 intra dc treshold != 0 decoding fixed
michael
parents: 1512
diff changeset
4827 *dc_val = block[0] * s->c_dc_scale;
ad5461bad820 intra dc treshold != 0 decoding fixed
michael
parents: 1512
diff changeset
4828 }
ad5461bad820 intra dc treshold != 0 decoding fixed
michael
parents: 1512
diff changeset
4829
ad5461bad820 intra dc treshold != 0 decoding fixed
michael
parents: 1512
diff changeset
4830 if(i == -1) i=0;
ad5461bad820 intra dc treshold != 0 decoding fixed
michael
parents: 1512
diff changeset
4831 }
ad5461bad820 intra dc treshold != 0 decoding fixed
michael
parents: 1512
diff changeset
4832
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4833 mpeg4_pred_ac(s, block, n, dc_pred_dir);
986e461dc072 Initial revision
glantau
parents:
diff changeset
4834 if (s->ac_pred) {
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4835 i = 63; /* XXX: not optimal */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4836 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
4837 }
549
218eb765c987 rl decoding optimization
michaelni
parents: 544
diff changeset
4838 s->block_last_index[n] = i;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4839 return 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
4840 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
4841
986e461dc072 Initial revision
glantau
parents:
diff changeset
4842 /* most is hardcoded. should extend to handle all h263 streams */
986e461dc072 Initial revision
glantau
parents:
diff changeset
4843 int h263_decode_picture_header(MpegEncContext *s)
986e461dc072 Initial revision
glantau
parents:
diff changeset
4844 {
1278
483db104bb7b truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents: 1273
diff changeset
4845 int format, width, height, i;
483db104bb7b truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents: 1273
diff changeset
4846 uint32_t startcode;
483db104bb7b truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents: 1273
diff changeset
4847
483db104bb7b truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents: 1273
diff changeset
4848 align_get_bits(&s->gb);
483db104bb7b truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents: 1273
diff changeset
4849
483db104bb7b truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents: 1273
diff changeset
4850 startcode= get_bits(&s->gb, 22-8);
483db104bb7b truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents: 1273
diff changeset
4851
1393
ba99a78bcb37 make the h263 decoder more error tolerant
michaelni
parents: 1390
diff changeset
4852 for(i= s->gb.size_in_bits - get_bits_count(&s->gb); i>24; i-=8) {
1278
483db104bb7b truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents: 1273
diff changeset
4853 startcode = ((startcode << 8) | get_bits(&s->gb, 8)) & 0x003FFFFF;
483db104bb7b truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents: 1273
diff changeset
4854
483db104bb7b truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents: 1273
diff changeset
4855 if(startcode == 0x20)
483db104bb7b truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents: 1273
diff changeset
4856 break;
483db104bb7b truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents: 1273
diff changeset
4857 }
483db104bb7b truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents: 1273
diff changeset
4858
483db104bb7b truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents: 1273
diff changeset
4859 if (startcode != 0x20) {
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1586
diff changeset
4860 av_log(s->avctx, AV_LOG_ERROR, "Bad picture start code\n");
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4861 return -1;
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4862 }
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4863 /* temporal reference */
231
840cd25bf259 - Fixes on RTP and GOB headers for H.263.
pulento
parents: 174
diff changeset
4864 s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4865
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4866 /* PTYPE starts here */
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4867 if (get_bits1(&s->gb) != 1) {
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4868 /* marker */
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1586
diff changeset
4869 av_log(s->avctx, AV_LOG_ERROR, "Bad marker\n");
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4870 return -1;
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4871 }
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4872 if (get_bits1(&s->gb) != 0) {
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1586
diff changeset
4873 av_log(s->avctx, AV_LOG_ERROR, "Bad H263 id\n");
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4874 return -1; /* h263 id */
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4875 }
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
4876 skip_bits1(&s->gb); /* split screen off */
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
4877 skip_bits1(&s->gb); /* camera off */
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
4878 skip_bits1(&s->gb); /* freeze picture release off */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4879
986e461dc072 Initial revision
glantau
parents:
diff changeset
4880 format = get_bits(&s->gb, 3);
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4881 /*
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4882 0 forbidden
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4883 1 sub-QCIF
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4884 10 QCIF
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4885 7 extended PTYPE (PLUSPTYPE)
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4886 */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4887
161
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
4888 if (format != 7 && format != 6) {
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4889 s->h263_plus = 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
4890 /* H.263v1 */
986e461dc072 Initial revision
glantau
parents:
diff changeset
4891 width = h263_format[format][0];
986e461dc072 Initial revision
glantau
parents:
diff changeset
4892 height = h263_format[format][1];
986e461dc072 Initial revision
glantau
parents:
diff changeset
4893 if (!width)
986e461dc072 Initial revision
glantau
parents:
diff changeset
4894 return -1;
161
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
4895
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
4896 s->pict_type = I_TYPE + get_bits1(&s->gb);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4897
1633
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
4898 s->h263_long_vectors = get_bits1(&s->gb);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4899
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4900 if (get_bits1(&s->gb) != 0) {
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1586
diff changeset
4901 av_log(s->avctx, AV_LOG_ERROR, "H263 SAC not supported\n");
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4902 return -1; /* SAC: off */
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4903 }
1633
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
4904 s->obmc= get_bits1(&s->gb); /* Advanced prediction mode */
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
4905 s->unrestricted_mv = s->h263_long_vectors || s->obmc;
161
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
4906
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4907 if (get_bits1(&s->gb) != 0) {
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1586
diff changeset
4908 av_log(s->avctx, AV_LOG_ERROR, "H263 PB frame not supported\n");
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4909 return -1; /* not PB frame */
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4910 }
1644
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
4911 s->chroma_qscale= s->qscale = get_bits(&s->gb, 5);
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
4912 skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */
1393
ba99a78bcb37 make the h263 decoder more error tolerant
michaelni
parents: 1390
diff changeset
4913
ba99a78bcb37 make the h263 decoder more error tolerant
michaelni
parents: 1390
diff changeset
4914 s->width = width;
ba99a78bcb37 make the h263 decoder more error tolerant
michaelni
parents: 1390
diff changeset
4915 s->height = height;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4916 } else {
161
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
4917 int ufep;
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
4918
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4919 /* H.263v2 */
161
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
4920 s->h263_plus = 1;
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
4921 ufep = get_bits(&s->gb, 3); /* Update Full Extended PTYPE */
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4922
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4923 /* ufep other than 0 and 1 are reserved */
161
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
4924 if (ufep == 1) {
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
4925 /* OPPTYPE */
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
4926 format = get_bits(&s->gb, 3);
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4927 dprintf("ufep=1, format: %d\n", format);
161
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
4928 skip_bits(&s->gb,1); /* Custom PCF */
1089
7e79a58954b1 h263(+) clenaup & bugfixes
michaelni
parents: 1070
diff changeset
4929 s->umvplus = get_bits(&s->gb, 1); /* Unrestricted Motion Vector */
1644
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
4930 if (get_bits1(&s->gb) != 0) {
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
4931 av_log(s->avctx, AV_LOG_ERROR, "Syntax-based Arithmetic Coding (SAC) not supported\n");
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
4932 }
1633
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
4933 s->obmc= get_bits1(&s->gb); /* Advanced prediction mode */
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
4934 s->h263_aic = get_bits1(&s->gb); /* Advanced Intra Coding (AIC) */
1644
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
4935 s->loop_filter= get_bits1(&s->gb);
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
4936 s->unrestricted_mv = s->umvplus || s->obmc || s->loop_filter;
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
4937
1661
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
4938 s->h263_slice_structured= get_bits1(&s->gb);
1278
483db104bb7b truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents: 1273
diff changeset
4939 if (get_bits1(&s->gb) != 0) {
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1586
diff changeset
4940 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
4941 }
483db104bb7b truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents: 1273
diff changeset
4942 if (get_bits1(&s->gb) != 0) {
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1586
diff changeset
4943 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
4944 }
1637
7799582dc9b8 h263 alternative inter vlc support
michael
parents: 1633
diff changeset
4945 s->alt_inter_vlc= get_bits1(&s->gb);
1639
3e2b774edce4 rv20 decoder
michael
parents: 1637
diff changeset
4946 s->modified_quant= get_bits1(&s->gb);
1644
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
4947 if(s->modified_quant)
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
4948 s->chroma_qscale_table= ff_h263_chroma_qscale_table;
1278
483db104bb7b truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents: 1273
diff changeset
4949
483db104bb7b truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents: 1273
diff changeset
4950 skip_bits(&s->gb, 1); /* Prevent start code emulation */
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4951
161
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
4952 skip_bits(&s->gb, 3); /* Reserved */
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4953 } else if (ufep != 0) {
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1586
diff changeset
4954 av_log(s->avctx, AV_LOG_ERROR, "Bad UFEP type (%d)\n", ufep);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4955 return -1;
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4956 }
161
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
4957
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
4958 /* MPPTYPE */
1655
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
4959 s->pict_type = get_bits(&s->gb, 3);
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
4960 switch(s->pict_type){
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
4961 case 0: s->pict_type= I_TYPE;break;
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
4962 case 1: s->pict_type= P_TYPE;break;
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
4963 case 3: s->pict_type= B_TYPE;break;
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
4964 case 7: s->pict_type= I_TYPE;break; //ZYGO
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
4965 default:
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
4966 return -1;
1655
c92147a61d97 rv20 (h263) b frame decoding support
michael
parents: 1652
diff changeset
4967 }
250
3449316664b5 - Bug fix on RTYPE (rounding type) not being honoured by H.263+ decoder.
pulento
parents: 249
diff changeset
4968 skip_bits(&s->gb, 2);
3449316664b5 - Bug fix on RTYPE (rounding type) not being honoured by H.263+ decoder.
pulento
parents: 249
diff changeset
4969 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
4970 skip_bits(&s->gb, 4);
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
4971
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
4972 /* Get the picture dimensions */
161
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
4973 if (ufep) {
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
4974 if (format == 6) {
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
4975 /* Custom Picture Format (CPFMT) */
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4976 s->aspect_ratio_info = get_bits(&s->gb, 4);
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4977 dprintf("aspect: %d\n", s->aspect_ratio_info);
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4978 /* aspect ratios:
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4979 0 - forbidden
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4980 1 - 1:1
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4981 2 - 12:11 (CIF 4:3)
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4982 3 - 10:11 (525-type 4:3)
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4983 4 - 16:11 (CIF 16:9)
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4984 5 - 40:33 (525-type 16:9)
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4985 6-14 - reserved
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4986 */
161
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
4987 width = (get_bits(&s->gb, 9) + 1) * 4;
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
4988 skip_bits1(&s->gb);
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
4989 height = get_bits(&s->gb, 9) * 4;
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4990 dprintf("\nH.263+ Custom picture: %dx%d\n",width,height);
669
b4bddbde44f3 aspect (ext. par too) support for h263 and mpeg4 (inc. build becouse of new vars)
al3x
parents: 667
diff changeset
4991 if (s->aspect_ratio_info == FF_ASPECT_EXTENDED) {
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4992 /* aspected dimensions */
1548
dd544554ed42 AVRational
michael
parents: 1542
diff changeset
4993 s->avctx->sample_aspect_ratio.num= get_bits(&s->gb, 8);
dd544554ed42 AVRational
michael
parents: 1542
diff changeset
4994 s->avctx->sample_aspect_ratio.den= get_bits(&s->gb, 8);
887
19f5b8b7c6d5 fixing aspect
michaelni
parents: 880
diff changeset
4995 }else{
1548
dd544554ed42 AVRational
michael
parents: 1542
diff changeset
4996 s->avctx->sample_aspect_ratio= pixel_aspect[s->aspect_ratio_info];
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4997 }
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
4998 } else {
161
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
4999 width = h263_format[format][0];
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
5000 height = h263_format[format][1];
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
5001 }
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
5002 if ((width == 0) || (height == 0))
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
5003 return -1;
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
5004 s->width = width;
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
5005 s->height = height;
1089
7e79a58954b1 h263(+) clenaup & bugfixes
michaelni
parents: 1070
diff changeset
5006 if (s->umvplus) {
7e79a58954b1 h263(+) clenaup & bugfixes
michaelni
parents: 1070
diff changeset
5007 if(get_bits1(&s->gb)==0) /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
7e79a58954b1 h263(+) clenaup & bugfixes
michaelni
parents: 1070
diff changeset
5008 skip_bits1(&s->gb);
161
7ce36cf13055 - Added support to Inter4V+Q MBs to H.263 decoder.
pulento
parents: 155
diff changeset
5009 }
1661
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
5010 if(s->h263_slice_structured){
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
5011 if (get_bits1(&s->gb) != 0) {
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
5012 av_log(s->avctx, AV_LOG_ERROR, "rectangular slices not supported\n");
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
5013 }
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
5014 if (get_bits1(&s->gb) != 0) {
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
5015 av_log(s->avctx, AV_LOG_ERROR, "unordered slices not supported\n");
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
5016 }
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
5017 }
78
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
5018 }
92ed1c4f94fa Added support to Unrestricted Motion Vectors (UMV)
pulento
parents: 70
diff changeset
5019
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
5020 s->qscale = get_bits(&s->gb, 5);
986e461dc072 Initial revision
glantau
parents:
diff changeset
5021 }
1670
d6f2520c0c43 slice structured fixes
michael
parents: 1668
diff changeset
5022
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
5023 /* PEI */
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
5024 while (get_bits1(&s->gb) != 0) {
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
5025 skip_bits(&s->gb, 8);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
5026 }
1670
d6f2520c0c43 slice structured fixes
michael
parents: 1668
diff changeset
5027
d6f2520c0c43 slice structured fixes
michael
parents: 1668
diff changeset
5028 if(s->h263_slice_structured){
d6f2520c0c43 slice structured fixes
michael
parents: 1668
diff changeset
5029 if (get_bits1(&s->gb) != 1) {
d6f2520c0c43 slice structured fixes
michael
parents: 1668
diff changeset
5030 av_log(s->avctx, AV_LOG_ERROR, "SEPB1 marker missing\n");
d6f2520c0c43 slice structured fixes
michael
parents: 1668
diff changeset
5031 return -1;
d6f2520c0c43 slice structured fixes
michael
parents: 1668
diff changeset
5032 }
d6f2520c0c43 slice structured fixes
michael
parents: 1668
diff changeset
5033
d6f2520c0c43 slice structured fixes
michael
parents: 1668
diff changeset
5034 ff_h263_decode_mba(s);
d6f2520c0c43 slice structured fixes
michael
parents: 1668
diff changeset
5035
d6f2520c0c43 slice structured fixes
michael
parents: 1668
diff changeset
5036 if (get_bits1(&s->gb) != 1) {
d6f2520c0c43 slice structured fixes
michael
parents: 1668
diff changeset
5037 av_log(s->avctx, AV_LOG_ERROR, "SEPB2 marker missing\n");
d6f2520c0c43 slice structured fixes
michael
parents: 1668
diff changeset
5038 return -1;
d6f2520c0c43 slice structured fixes
michael
parents: 1668
diff changeset
5039 }
d6f2520c0c43 slice structured fixes
michael
parents: 1668
diff changeset
5040 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
5041 s->f_code = 1;
498
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
5042
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
5043 if(s->h263_aic){
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
5044 s->y_dc_scale_table=
1639
3e2b774edce4 rv20 decoder
michael
parents: 1637
diff changeset
5045 s->c_dc_scale_table= ff_aic_dc_scale_table;
498
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
5046 }else{
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
5047 s->y_dc_scale_table=
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
5048 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
5049 }
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
5050
1278
483db104bb7b truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents: 1273
diff changeset
5051 if(s->avctx->debug&FF_DEBUG_PICT_INFO){
1661
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
5052 av_log(s->avctx, AV_LOG_DEBUG, "qp:%d %c size:%d rnd:%d%s%s%s%s%s%s%s%s%s\n",
1278
483db104bb7b truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents: 1273
diff changeset
5053 s->qscale, av_get_pict_type_char(s->pict_type),
483db104bb7b truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents: 1273
diff changeset
5054 s->gb.size_in_bits, 1-s->no_rounding,
1633
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
5055 s->obmc ? " AP" : "",
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
5056 s->umvplus ? " UMV" : "",
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
5057 s->h263_long_vectors ? " LONG" : "",
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
5058 s->h263_plus ? " +" : "",
1637
7799582dc9b8 h263 alternative inter vlc support
michael
parents: 1633
diff changeset
5059 s->h263_aic ? " AIC" : "",
1639
3e2b774edce4 rv20 decoder
michael
parents: 1637
diff changeset
5060 s->alt_inter_vlc ? " AIV" : "",
1644
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
5061 s->modified_quant ? " MQ" : "",
1661
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
5062 s->loop_filter ? " LOOP" : "",
4c9fd29f1606 h263 slice structured mode
michael
parents: 1659
diff changeset
5063 s->h263_slice_structured ? " SS" : ""
1278
483db104bb7b truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents: 1273
diff changeset
5064 );
483db104bb7b truncated h263 decoding support / H263-ES "demuxer"
michaelni
parents: 1273
diff changeset
5065 }
1584
3615999a7284 dumping funny numbers from first zygo i frame header
michael
parents: 1583
diff changeset
5066 #if 1
3615999a7284 dumping funny numbers from first zygo i frame header
michael
parents: 1583
diff changeset
5067 if (s->pict_type == I_TYPE && s->avctx->codec_tag == ff_get_fourcc("ZYGO")){
3615999a7284 dumping funny numbers from first zygo i frame header
michael
parents: 1583
diff changeset
5068 int i,j;
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1586
diff changeset
5069 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
5070 av_log(s->avctx, AV_LOG_DEBUG, "\n");
1584
3615999a7284 dumping funny numbers from first zygo i frame header
michael
parents: 1583
diff changeset
5071 for(i=0; i<13; i++){
3615999a7284 dumping funny numbers from first zygo i frame header
michael
parents: 1583
diff changeset
5072 for(j=0; j<3; j++){
3615999a7284 dumping funny numbers from first zygo i frame header
michael
parents: 1583
diff changeset
5073 int v= get_bits(&s->gb, 8);
3615999a7284 dumping funny numbers from first zygo i frame header
michael
parents: 1583
diff changeset
5074 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
5075 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
5076 }
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1586
diff changeset
5077 av_log(s->avctx, AV_LOG_DEBUG, "\n");
1584
3615999a7284 dumping funny numbers from first zygo i frame header
michael
parents: 1583
diff changeset
5078 }
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1586
diff changeset
5079 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
5080 }
3615999a7284 dumping funny numbers from first zygo i frame header
michael
parents: 1583
diff changeset
5081 #endif
3615999a7284 dumping funny numbers from first zygo i frame header
michael
parents: 1583
diff changeset
5082
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
5083 return 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
5084 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
5085
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
5086 static void mpeg4_decode_sprite_trajectory(MpegEncContext * s)
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
5087 {
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
5088 int i;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
5089 int a= 2<<s->sprite_warping_accuracy;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
5090 int rho= 3-s->sprite_warping_accuracy;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
5091 int r=16/a;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
5092 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
5093 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
5094 int sprite_ref[4][2];
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
5095 int virtual_ref[2][2];
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5096 int w2, h2, w3, h3;
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
5097 int alpha=0, beta=0;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
5098 int w= s->width;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
5099 int h= s->height;
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5100 int min_ab;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5101
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
5102 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
5103 int length;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
5104 int x=0, y=0;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
5105
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
5106 length= get_vlc(&s->gb, &sprite_trajectory);
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
5107 if(length){
1254
604661d34c68 bitstream reader optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents: 1237
diff changeset
5108 x= get_xbits(&s->gb, length);
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
5109 }
255
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
5110 if(!(s->divx_version==500 && s->divx_build==413)) skip_bits1(&s->gb); /* marker bit */
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
5111
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
5112 length= get_vlc(&s->gb, &sprite_trajectory);
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
5113 if(length){
1254
604661d34c68 bitstream reader optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents: 1237
diff changeset
5114 y=get_xbits(&s->gb, length);
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
5115 }
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
5116 skip_bits1(&s->gb); /* marker bit */
255
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
5117 //printf("%d %d %d %d\n", x, y, i, s->sprite_warping_accuracy);
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
5118 d[i][0]= x;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
5119 d[i][1]= y;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
5120 }
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
5121
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
5122 while((1<<alpha)<w) alpha++;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
5123 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
5124 w2= 1<<alpha;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
5125 h2= 1<<beta;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
5126
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
5127 // Note, the 4th point isnt used for GMC
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
5128 if(s->divx_version==500 && s->divx_build==413){
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
5129 sprite_ref[0][0]= a*vop_ref[0][0] + d[0][0];
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
5130 sprite_ref[0][1]= a*vop_ref[0][1] + d[0][1];
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
5131 sprite_ref[1][0]= a*vop_ref[1][0] + d[0][0] + d[1][0];
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
5132 sprite_ref[1][1]= a*vop_ref[1][1] + d[0][1] + d[1][1];
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
5133 sprite_ref[2][0]= a*vop_ref[2][0] + d[0][0] + d[2][0];
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
5134 sprite_ref[2][1]= a*vop_ref[2][1] + d[0][1] + d[2][1];
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
5135 } else {
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
5136 sprite_ref[0][0]= (a>>1)*(2*vop_ref[0][0] + d[0][0]);
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
5137 sprite_ref[0][1]= (a>>1)*(2*vop_ref[0][1] + d[0][1]);
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
5138 sprite_ref[1][0]= (a>>1)*(2*vop_ref[1][0] + d[0][0] + d[1][0]);
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
5139 sprite_ref[1][1]= (a>>1)*(2*vop_ref[1][1] + d[0][1] + d[1][1]);
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
5140 sprite_ref[2][0]= (a>>1)*(2*vop_ref[2][0] + d[0][0] + d[2][0]);
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
5141 sprite_ref[2][1]= (a>>1)*(2*vop_ref[2][1] + d[0][1] + d[2][1]);
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
5142 }
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
5143 /* 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
5144 sprite_ref[3][1]= (a>>1)*(2*vop_ref[3][1] + d[0][1] + d[1][1] + d[2][1] + d[3][1]); */
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
5145
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
5146 // 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
5147 // 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
5148 // 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
5149 // so the distance between points is converted from w&h based to w2&h2 based which are of the 2^x form
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
5150 virtual_ref[0][0]= 16*(vop_ref[0][0] + w2)
359
df0736462b9f move ABS() to common.h
michaelni
parents: 358
diff changeset
5151 + ROUNDED_DIV(((w - w2)*(r*sprite_ref[0][0] - 16*vop_ref[0][0]) + w2*(r*sprite_ref[1][0] - 16*vop_ref[1][0])),w);
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
5152 virtual_ref[0][1]= 16*vop_ref[0][1]
359
df0736462b9f move ABS() to common.h
michaelni
parents: 358
diff changeset
5153 + ROUNDED_DIV(((w - w2)*(r*sprite_ref[0][1] - 16*vop_ref[0][1]) + w2*(r*sprite_ref[1][1] - 16*vop_ref[1][1])),w);
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
5154 virtual_ref[1][0]= 16*vop_ref[0][0]
359
df0736462b9f move ABS() to common.h
michaelni
parents: 358
diff changeset
5155 + ROUNDED_DIV(((h - h2)*(r*sprite_ref[0][0] - 16*vop_ref[0][0]) + h2*(r*sprite_ref[2][0] - 16*vop_ref[2][0])),h);
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
5156 virtual_ref[1][1]= 16*(vop_ref[0][1] + h2)
359
df0736462b9f move ABS() to common.h
michaelni
parents: 358
diff changeset
5157 + ROUNDED_DIV(((h - h2)*(r*sprite_ref[0][1] - 16*vop_ref[0][1]) + h2*(r*sprite_ref[2][1] - 16*vop_ref[2][1])),h);
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5158
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
5159 switch(s->num_sprite_warping_points)
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
5160 {
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
5161 case 0:
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
5162 s->sprite_offset[0][0]= 0;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
5163 s->sprite_offset[0][1]= 0;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
5164 s->sprite_offset[1][0]= 0;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
5165 s->sprite_offset[1][1]= 0;
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5166 s->sprite_delta[0][0]= a;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5167 s->sprite_delta[0][1]= 0;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5168 s->sprite_delta[1][0]= 0;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5169 s->sprite_delta[1][1]= a;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5170 s->sprite_shift[0]= 0;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5171 s->sprite_shift[1]= 0;
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
5172 break;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
5173 case 1: //GMC only
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
5174 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
5175 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
5176 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
5177 s->sprite_offset[1][1]= ((sprite_ref[0][1]>>1)|(sprite_ref[0][1]&1)) - a*(vop_ref[0][1]/2);
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5178 s->sprite_delta[0][0]= a;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5179 s->sprite_delta[0][1]= 0;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5180 s->sprite_delta[1][0]= 0;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5181 s->sprite_delta[1][1]= a;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5182 s->sprite_shift[0]= 0;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5183 s->sprite_shift[1]= 0;
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
5184 break;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
5185 case 2:
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
5186 s->sprite_offset[0][0]= (sprite_ref[0][0]<<(alpha+rho))
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5187 + (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][0])
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5188 + ( r*sprite_ref[0][1] - virtual_ref[0][1])*(-vop_ref[0][1])
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5189 + (1<<(alpha+rho-1));
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
5190 s->sprite_offset[0][1]= (sprite_ref[0][1]<<(alpha+rho))
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5191 + (-r*sprite_ref[0][1] + virtual_ref[0][1])*(-vop_ref[0][0])
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5192 + (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][1])
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5193 + (1<<(alpha+rho-1));
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5194 s->sprite_offset[1][0]= ( (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][0] + 1)
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5195 +( r*sprite_ref[0][1] - virtual_ref[0][1])*(-2*vop_ref[0][1] + 1)
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5196 +2*w2*r*sprite_ref[0][0]
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5197 - 16*w2
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5198 + (1<<(alpha+rho+1)));
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5199 s->sprite_offset[1][1]= ( (-r*sprite_ref[0][1] + virtual_ref[0][1])*(-2*vop_ref[0][0] + 1)
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5200 +(-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][1] + 1)
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5201 +2*w2*r*sprite_ref[0][1]
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5202 - 16*w2
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5203 + (1<<(alpha+rho+1)));
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5204 s->sprite_delta[0][0]= (-r*sprite_ref[0][0] + virtual_ref[0][0]);
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5205 s->sprite_delta[0][1]= (+r*sprite_ref[0][1] - virtual_ref[0][1]);
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5206 s->sprite_delta[1][0]= (-r*sprite_ref[0][1] + virtual_ref[0][1]);
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5207 s->sprite_delta[1][1]= (-r*sprite_ref[0][0] + virtual_ref[0][0]);
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5208
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5209 s->sprite_shift[0]= alpha+rho;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5210 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
5211 break;
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5212 case 3:
847
f3c369b8ddca reversing header game
michaelni
parents: 821
diff changeset
5213 min_ab= FFMIN(alpha, beta);
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5214 w3= w2>>min_ab;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5215 h3= h2>>min_ab;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5216 s->sprite_offset[0][0]= (sprite_ref[0][0]<<(alpha+beta+rho-min_ab))
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5217 + (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3*(-vop_ref[0][0])
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5218 + (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3*(-vop_ref[0][1])
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5219 + (1<<(alpha+beta+rho-min_ab-1));
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5220 s->sprite_offset[0][1]= (sprite_ref[0][1]<<(alpha+beta+rho-min_ab))
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5221 + (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3*(-vop_ref[0][0])
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5222 + (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3*(-vop_ref[0][1])
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5223 + (1<<(alpha+beta+rho-min_ab-1));
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5224 s->sprite_offset[1][0]= (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3*(-2*vop_ref[0][0] + 1)
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5225 + (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3*(-2*vop_ref[0][1] + 1)
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5226 + 2*w2*h3*r*sprite_ref[0][0]
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5227 - 16*w2*h3
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5228 + (1<<(alpha+beta+rho-min_ab+1));
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5229 s->sprite_offset[1][1]= (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3*(-2*vop_ref[0][0] + 1)
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5230 + (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3*(-2*vop_ref[0][1] + 1)
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5231 + 2*w2*h3*r*sprite_ref[0][1]
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5232 - 16*w2*h3
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5233 + (1<<(alpha+beta+rho-min_ab+1));
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5234 s->sprite_delta[0][0]= (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5235 s->sprite_delta[0][1]= (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5236 s->sprite_delta[1][0]= (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5237 s->sprite_delta[1][1]= (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5238
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5239 s->sprite_shift[0]= alpha + beta + rho - min_ab;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5240 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
5241 break;
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
5242 }
255
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
5243 /* try to simplify the situation */
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5244 if( s->sprite_delta[0][0] == a<<s->sprite_shift[0]
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5245 && s->sprite_delta[0][1] == 0
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5246 && s->sprite_delta[1][0] == 0
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5247 && s->sprite_delta[1][1] == a<<s->sprite_shift[0])
255
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
5248 {
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5249 s->sprite_offset[0][0]>>=s->sprite_shift[0];
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5250 s->sprite_offset[0][1]>>=s->sprite_shift[0];
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5251 s->sprite_offset[1][0]>>=s->sprite_shift[1];
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5252 s->sprite_offset[1][1]>>=s->sprite_shift[1];
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5253 s->sprite_delta[0][0]= a;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5254 s->sprite_delta[0][1]= 0;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5255 s->sprite_delta[1][0]= 0;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5256 s->sprite_delta[1][1]= a;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5257 s->sprite_shift[0]= 0;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5258 s->sprite_shift[1]= 0;
255
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
5259 s->real_sprite_warping_points=1;
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
5260 }
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5261 else{
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5262 int shift_y= 16 - s->sprite_shift[0];
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5263 int shift_c= 16 - s->sprite_shift[1];
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5264 //printf("shifts %d %d\n", shift_y, shift_c);
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5265 for(i=0; i<2; i++){
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5266 s->sprite_offset[0][i]<<= shift_y;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5267 s->sprite_offset[1][i]<<= shift_c;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5268 s->sprite_delta[0][i]<<= shift_y;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5269 s->sprite_delta[1][i]<<= shift_y;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5270 s->sprite_shift[i]= 16;
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5271 }
255
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
5272 s->real_sprite_warping_points= s->num_sprite_warping_points;
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5273 }
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5274 #if 0
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5275 printf("vop:%d:%d %d:%d %d:%d, sprite:%d:%d %d:%d %d:%d, virtual: %d:%d %d:%d\n",
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5276 vop_ref[0][0], vop_ref[0][1],
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5277 vop_ref[1][0], vop_ref[1][1],
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5278 vop_ref[2][0], vop_ref[2][1],
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5279 sprite_ref[0][0], sprite_ref[0][1],
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5280 sprite_ref[1][0], sprite_ref[1][1],
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5281 sprite_ref[2][0], sprite_ref[2][1],
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5282 virtual_ref[0][0], virtual_ref[0][1],
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5283 virtual_ref[1][0], virtual_ref[1][1]
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5284 );
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5285
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5286 printf("offset: %d:%d , delta: %d %d %d %d, shift %d\n",
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5287 s->sprite_offset[0][0], s->sprite_offset[0][1],
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5288 s->sprite_delta[0][0], s->sprite_delta[0][1],
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5289 s->sprite_delta[1][0], s->sprite_delta[1][1],
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5290 s->sprite_shift[0]
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5291 );
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5292 #endif
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
5293 }
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
5294
942
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
5295 static int mpeg4_decode_gop_header(MpegEncContext * s, GetBitContext *gb){
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
5296 int hours, minutes, seconds;
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
5297
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
5298 hours= get_bits(gb, 5);
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
5299 minutes= get_bits(gb, 6);
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
5300 skip_bits1(gb);
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
5301 seconds= get_bits(gb, 6);
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
5302
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
5303 s->time_base= seconds + 60*(minutes + 60*hours);
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
5304
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
5305 skip_bits1(gb);
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
5306 skip_bits1(gb);
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
5307
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
5308 return 0;
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
5309 }
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
5310
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5311 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
5312 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
5313
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5314 /* vol header */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5315 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
5316 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
5317 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
5318 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
5319 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
5320 } else {
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5321 vo_ver_id = 1;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5322 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5323 //printf("vo type:%d\n",s->vo_type);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5324 s->aspect_ratio_info= get_bits(gb, 4);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5325 if(s->aspect_ratio_info == FF_ASPECT_EXTENDED){
1548
dd544554ed42 AVRational
michael
parents: 1542
diff changeset
5326 s->avctx->sample_aspect_ratio.num= get_bits(gb, 8); // par_width
dd544554ed42 AVRational
michael
parents: 1542
diff changeset
5327 s->avctx->sample_aspect_ratio.den= get_bits(gb, 8); // par_height
887
19f5b8b7c6d5 fixing aspect
michaelni
parents: 880
diff changeset
5328 }else{
1548
dd544554ed42 AVRational
michael
parents: 1542
diff changeset
5329 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
5330 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5331
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5332 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
5333 int chroma_format= get_bits(gb, 2);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5334 if(chroma_format!=1){
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1586
diff changeset
5335 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
5336 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5337 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
5338 if(get_bits1(gb)){ /* vbv parameters */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5339 get_bits(gb, 15); /* first_half_bitrate */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5340 skip_bits1(gb); /* marker */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5341 get_bits(gb, 15); /* latter_half_bitrate */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5342 skip_bits1(gb); /* marker */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5343 get_bits(gb, 15); /* first_half_vbv_buffer_size */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5344 skip_bits1(gb); /* marker */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5345 get_bits(gb, 3); /* latter_half_vbv_buffer_size */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5346 get_bits(gb, 11); /* first_half_vbv_occupancy */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5347 skip_bits1(gb); /* marker */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5348 get_bits(gb, 15); /* latter_half_vbv_occupancy */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5349 skip_bits1(gb); /* marker */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5350 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5351 }else{
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5352 // set low delay flag only once so the smart? low delay detection wont be overriden
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5353 if(s->picture_number==0)
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5354 s->low_delay=0;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5355 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5356
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5357 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
5358 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
5359 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
5360 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
5361 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
5362 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5363
1411
c2e63cb94d06 custom quant matrix encoding support
michaelni
parents: 1396
diff changeset
5364 check_marker(gb, "before time_increment_resolution");
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5365
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5366 s->time_increment_resolution = get_bits(gb, 16);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5367
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5368 s->time_increment_bits = av_log2(s->time_increment_resolution - 1) + 1;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5369 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
5370 s->time_increment_bits = 1;
1411
c2e63cb94d06 custom quant matrix encoding support
michaelni
parents: 1396
diff changeset
5371
c2e63cb94d06 custom quant matrix encoding support
michaelni
parents: 1396
diff changeset
5372 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
5373
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5374 if (get_bits1(gb) != 0) { /* fixed_vop_rate */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5375 skip_bits(gb, s->time_increment_bits);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5376 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5377
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5378 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
5379 if (s->shape == RECT_SHAPE) {
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5380 skip_bits1(gb); /* marker */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5381 width = get_bits(gb, 13);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5382 skip_bits1(gb); /* marker */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5383 height = get_bits(gb, 13);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5384 skip_bits1(gb); /* marker */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5385 if(width && height){ /* they should be non zero but who knows ... */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5386 s->width = width;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5387 s->height = height;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5388 // printf("width/height: %d %d\n", width, height);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5389 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5390 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5391
1659
3075fc11a974 AVFrame.interlaced_frame fixes
michael
parents: 1656
diff changeset
5392 s->progressive_sequence=
3075fc11a974 AVFrame.interlaced_frame fixes
michael
parents: 1656
diff changeset
5393 s->progressive_frame= get_bits1(gb)^1;
1237
6ce5cde4e1d4 print obmc bug info only if avctx->debug&1
michaelni
parents: 1177
diff changeset
5394 if(!get_bits1(gb) && (s->avctx->debug & FF_DEBUG_PICT_INFO))
1644
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
5395 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
5396 if (vo_ver_id == 1) {
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5397 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
5398 } else {
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5399 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
5400 }
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1586
diff changeset
5401 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
5402 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
5403 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
5404 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
5405 skip_bits1(gb); /* marker */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5406 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
5407 skip_bits1(gb); /* marker */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5408 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
5409 skip_bits1(gb); /* marker */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5410 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
5411 skip_bits1(gb); /* marker */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5412 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5413 s->num_sprite_warping_points= get_bits(gb, 6);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5414 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
5415 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
5416 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
5417 s->low_latency_sprite= get_bits1(gb);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5418 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5419 // FIXME sadct disable bit if verid!=1 && shape not rect
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5420
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5421 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
5422 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
5423 if(get_bits(gb, 4)!=8) av_log(s->avctx, AV_LOG_ERROR, "N-bit not supported\n"); /* bits_per_pixel */
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1586
diff changeset
5424 if(s->quant_precision!=5) av_log(s->avctx, AV_LOG_ERROR, "quant precission %d\n", s->quant_precision);
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5425 } else {
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5426 s->quant_precision = 5;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
5427 }
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5428
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5429 // 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
5430
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5431 if((s->mpeg_quant=get_bits1(gb))){ /* vol_quant_type */
1057
bb5de8a59da8 * static,const,compiler warning cleanup
kabi
parents: 1053
diff changeset
5432 int i, v;
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5433
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5434 /* load default matrixes */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5435 for(i=0; i<64; i++){
1092
f59c3f66363b MpegEncContext.(i)dct_* -> DspContext.(i)dct_*
michaelni
parents: 1090
diff changeset
5436 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
5437 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
5438 s->intra_matrix[j]= v;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5439 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
5440
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5441 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
5442 s->inter_matrix[j]= v;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5443 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
5444 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5445
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5446 /* load custom intra matrix */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5447 if(get_bits1(gb)){
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5448 int last=0;
1057
bb5de8a59da8 * static,const,compiler warning cleanup
kabi
parents: 1053
diff changeset
5449 for(i=0; i<64; i++){
bb5de8a59da8 * static,const,compiler warning cleanup
kabi
parents: 1053
diff changeset
5450 int j;
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5451 v= get_bits(gb, 8);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5452 if(v==0) break;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5453
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5454 last= v;
1092
f59c3f66363b MpegEncContext.(i)dct_* -> DspContext.(i)dct_*
michaelni
parents: 1090
diff changeset
5455 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
5456 s->intra_matrix[j]= v;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5457 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
5458 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5459
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5460 /* replicate last value */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5461 for(; i<64; i++){
1092
f59c3f66363b MpegEncContext.(i)dct_* -> DspContext.(i)dct_*
michaelni
parents: 1090
diff changeset
5462 int j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
1411
c2e63cb94d06 custom quant matrix encoding support
michaelni
parents: 1396
diff changeset
5463 s->intra_matrix[j]= last;
c2e63cb94d06 custom quant matrix encoding support
michaelni
parents: 1396
diff changeset
5464 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
5465 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5466 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5467
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5468 /* load custom non intra matrix */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5469 if(get_bits1(gb)){
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5470 int last=0;
1057
bb5de8a59da8 * static,const,compiler warning cleanup
kabi
parents: 1053
diff changeset
5471 for(i=0; i<64; i++){
bb5de8a59da8 * static,const,compiler warning cleanup
kabi
parents: 1053
diff changeset
5472 int j;
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5473 v= get_bits(gb, 8);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5474 if(v==0) break;
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 last= v;
1092
f59c3f66363b MpegEncContext.(i)dct_* -> DspContext.(i)dct_*
michaelni
parents: 1090
diff changeset
5477 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
5478 s->inter_matrix[j]= v;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5479 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
5480 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5481
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5482 /* replicate last value */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5483 for(; i<64; i++){
1092
f59c3f66363b MpegEncContext.(i)dct_* -> DspContext.(i)dct_*
michaelni
parents: 1090
diff changeset
5484 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
5485 s->inter_matrix[j]= last;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5486 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
5487 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5488 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5489
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5490 // 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
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(vo_ver_id != 1)
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5494 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
5495 else s->quarter_sample=0;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5496
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1586
diff changeset
5497 if(!get_bits1(gb)) av_log(s->avctx, AV_LOG_ERROR, "Complexity estimation not supported\n");
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5498
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5499 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
5500
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5501 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
5502 if(s->data_partitioning){
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5503 s->rvlc= get_bits1(gb);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5504 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5505
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5506 if(vo_ver_id != 1) {
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5507 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
5508 if(s->new_pred){
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1586
diff changeset
5509 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
5510 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
5511 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
5512 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5513 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
5514 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
5515 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5516 else{
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5517 s->new_pred=0;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5518 s->reduced_res_vop= 0;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5519 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5520
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5521 s->scalability= get_bits1(gb);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5522
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5523 if (s->scalability) {
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5524 GetBitContext bak= *gb;
751
cbe316f082bc warning fixes
michaelni
parents: 747
diff changeset
5525 int ref_layer_id;
cbe316f082bc warning fixes
michaelni
parents: 747
diff changeset
5526 int ref_layer_sampling_dir;
cbe316f082bc warning fixes
michaelni
parents: 747
diff changeset
5527 int h_sampling_factor_n;
cbe316f082bc warning fixes
michaelni
parents: 747
diff changeset
5528 int h_sampling_factor_m;
cbe316f082bc warning fixes
michaelni
parents: 747
diff changeset
5529 int v_sampling_factor_n;
cbe316f082bc warning fixes
michaelni
parents: 747
diff changeset
5530 int v_sampling_factor_m;
cbe316f082bc warning fixes
michaelni
parents: 747
diff changeset
5531
cbe316f082bc warning fixes
michaelni
parents: 747
diff changeset
5532 s->hierachy_type= get_bits1(gb);
cbe316f082bc warning fixes
michaelni
parents: 747
diff changeset
5533 ref_layer_id= get_bits(gb, 4);
cbe316f082bc warning fixes
michaelni
parents: 747
diff changeset
5534 ref_layer_sampling_dir= get_bits1(gb);
cbe316f082bc warning fixes
michaelni
parents: 747
diff changeset
5535 h_sampling_factor_n= get_bits(gb, 5);
cbe316f082bc warning fixes
michaelni
parents: 747
diff changeset
5536 h_sampling_factor_m= get_bits(gb, 5);
cbe316f082bc warning fixes
michaelni
parents: 747
diff changeset
5537 v_sampling_factor_n= get_bits(gb, 5);
cbe316f082bc warning fixes
michaelni
parents: 747
diff changeset
5538 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
5539 s->enhancement_type= get_bits1(gb);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5540
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5541 if( h_sampling_factor_n==0 || h_sampling_factor_m==0
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5542 || v_sampling_factor_n==0 || v_sampling_factor_m==0){
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5543
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5544 // fprintf(stderr, "illegal scalability header (VERY broken encoder), trying to workaround\n");
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5545 s->scalability=0;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5546
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5547 *gb= bak;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5548 }else
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1586
diff changeset
5549 av_log(s->avctx, AV_LOG_ERROR, "scalability not supported\n");
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5550
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5551 // bin shape stuff FIXME
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5552 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5553 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5554 return 0;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5555 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5556
1034
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
5557 /**
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
5558 * decodes the user data stuff in the header.
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
5559 * allso inits divx/xvid/lavc_version/build
af7ba8d8b43a feeding doxygen
michaelni
parents: 1025
diff changeset
5560 */
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5561 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
5562 char buf[256];
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5563 int i;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5564 int e;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5565 int ver, build, ver2, ver3;
1145
79e8ed620b17 better non conformant divx packed bitstream detection, so unpacked (no b frames) divx MPEG4-ES streams can be read
michaelni
parents: 1144
diff changeset
5566 char last;
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5567
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5568 buf[0]= show_bits(gb, 8);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5569 for(i=1; i<256; i++){
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5570 buf[i]= show_bits(gb, 16)&0xFF;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5571 if(buf[i]==0) break;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5572 skip_bits(gb, 8);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5573 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5574 buf[255]=0;
1145
79e8ed620b17 better non conformant divx packed bitstream detection, so unpacked (no b frames) divx MPEG4-ES streams can be read
michaelni
parents: 1144
diff changeset
5575
761
7f4cc2f6d642 xvid qpel bug autodetect
michaelni
parents: 757
diff changeset
5576 /* 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
5577 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
5578 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
5579 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
5580 if(e>=2){
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5581 s->divx_version= ver;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5582 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
5583 s->divx_packed= e==3 && last=='p';
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
5584 }
761
7f4cc2f6d642 xvid qpel bug autodetect
michaelni
parents: 757
diff changeset
5585
7f4cc2f6d642 xvid qpel bug autodetect
michaelni
parents: 757
diff changeset
5586 /* ffmpeg detection */
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5587 e=sscanf(buf, "FFmpeg%d.%d.%db%d", &ver, &ver2, &ver3, &build);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5588 if(e!=4)
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5589 e=sscanf(buf, "FFmpeg v%d.%d.%d / libavcodec build: %d", &ver, &ver2, &ver3, &build);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5590 if(e!=4){
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5591 if(strcmp(buf, "ffmpeg")==0){
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5592 s->ffmpeg_version= 0x000406;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5593 s->lavc_build= 4600;
63
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
5594 }
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5595 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5596 if(e==4){
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5597 s->ffmpeg_version= ver*256*256 + ver2*256 + ver3;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5598 s->lavc_build= build;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5599 }
761
7f4cc2f6d642 xvid qpel bug autodetect
michaelni
parents: 757
diff changeset
5600
7f4cc2f6d642 xvid qpel bug autodetect
michaelni
parents: 757
diff changeset
5601 /* xvid detection */
7f4cc2f6d642 xvid qpel bug autodetect
michaelni
parents: 757
diff changeset
5602 e=sscanf(buf, "XviD%d", &build);
7f4cc2f6d642 xvid qpel bug autodetect
michaelni
parents: 757
diff changeset
5603 if(e==1){
7f4cc2f6d642 xvid qpel bug autodetect
michaelni
parents: 757
diff changeset
5604 s->xvid_build= build;
7f4cc2f6d642 xvid qpel bug autodetect
michaelni
parents: 757
diff changeset
5605 }
7f4cc2f6d642 xvid qpel bug autodetect
michaelni
parents: 757
diff changeset
5606
255
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
5607 //printf("User Data: %s\n", buf);
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5608 return 0;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5609 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5610
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5611 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
5612 int time_incr, time_increment;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5613
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5614 s->pict_type = get_bits(gb, 2) + I_TYPE; /* pict type: I = 0 , P = 1 */
1346
44c94325810c CODEC_FLAG_LOW_DELAY fix
michaelni
parents: 1278
diff changeset
5615 if(s->pict_type==B_TYPE && s->low_delay && s->vol_control_parameters==0 && !(s->flags & CODEC_FLAG_LOW_DELAY)){
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1586
diff changeset
5616 av_log(s->avctx, AV_LOG_ERROR, "low_delay flag set, but shouldnt, clearing it\n");
365
fdeec2834c79 there are divx5? encoded files without a userdata section but with b-frames :(
michaelni
parents: 364
diff changeset
5617 s->low_delay=0;
fdeec2834c79 there are divx5? encoded files without a userdata section but with b-frames :(
michaelni
parents: 364
diff changeset
5618 }
753
8e1f0939d15d complete mpeg4 GMC decoding support
michaelni
parents: 751
diff changeset
5619
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
5620 s->partitioned_frame= s->data_partitioning && s->pict_type!=B_TYPE;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
5621 if(s->partitioned_frame)
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
5622 s->decode_mb= mpeg4_decode_partitioned_mb;
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
5623 else
1649
e6a474a5b929 split ff_h263_decode_mb() into h263 and mpeg4 versions
michael
parents: 1646
diff changeset
5624 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
5625
662
5a158f0d1981 fixing 1/0 if the headers are incomplete (like what M$ encoder generates)
michaelni
parents: 661
diff changeset
5626 if(s->time_increment_resolution==0){
5a158f0d1981 fixing 1/0 if the headers are incomplete (like what M$ encoder generates)
michaelni
parents: 661
diff changeset
5627 s->time_increment_resolution=1;
5a158f0d1981 fixing 1/0 if the headers are incomplete (like what M$ encoder generates)
michaelni
parents: 661
diff changeset
5628 // fprintf(stderr, "time_increment_resolution is illegal\n");
5a158f0d1981 fixing 1/0 if the headers are incomplete (like what M$ encoder generates)
michaelni
parents: 661
diff changeset
5629 }
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
5630 time_incr=0;
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5631 while (get_bits1(gb) != 0)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
5632 time_incr++;
986e461dc072 Initial revision
glantau
parents:
diff changeset
5633
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5634 check_marker(gb, "before time_increment");
1068
a5be963709d1 improving parsing of incomplete headers
michaelni
parents: 1064
diff changeset
5635
1396
e380ac39024a cleanup / fixes
michaelni
parents: 1393
diff changeset
5636 if(s->time_increment_bits==0){
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1586
diff changeset
5637 av_log(s->avctx, AV_LOG_ERROR, "hmm, seems the headers arnt complete, trying to guess time_increment_bits\n");
1068
a5be963709d1 improving parsing of incomplete headers
michaelni
parents: 1064
diff changeset
5638
a5be963709d1 improving parsing of incomplete headers
michaelni
parents: 1064
diff changeset
5639 for(s->time_increment_bits=1 ;s->time_increment_bits<16; s->time_increment_bits++){
a5be963709d1 improving parsing of incomplete headers
michaelni
parents: 1064
diff changeset
5640 if(show_bits(gb, s->time_increment_bits+1)&1) break;
a5be963709d1 improving parsing of incomplete headers
michaelni
parents: 1064
diff changeset
5641 }
1396
e380ac39024a cleanup / fixes
michaelni
parents: 1393
diff changeset
5642
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1586
diff changeset
5643 av_log(s->avctx, AV_LOG_ERROR, "my guess is %d bits ;)\n",s->time_increment_bits);
1068
a5be963709d1 improving parsing of incomplete headers
michaelni
parents: 1064
diff changeset
5644 }
a5be963709d1 improving parsing of incomplete headers
michaelni
parents: 1064
diff changeset
5645
1411
c2e63cb94d06 custom quant matrix encoding support
michaelni
parents: 1396
diff changeset
5646 if(IS_3IV1) time_increment= get_bits1(gb); //FIXME investigate further
c2e63cb94d06 custom quant matrix encoding support
michaelni
parents: 1396
diff changeset
5647 else time_increment= get_bits(gb, s->time_increment_bits);
c2e63cb94d06 custom quant matrix encoding support
michaelni
parents: 1396
diff changeset
5648
c2e63cb94d06 custom quant matrix encoding support
michaelni
parents: 1396
diff changeset
5649 // printf("%d %X\n", s->time_increment_bits, time_increment);
697
c622224012f0 mpeg4 interlaced dct encoding
michaelni
parents: 695
diff changeset
5650 //printf(" type:%d modulo_time_base:%d increment:%d\n", s->pict_type, time_incr, time_increment);
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
5651 if(s->pict_type!=B_TYPE){
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
5652 s->last_time_base= s->time_base;
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
5653 s->time_base+= time_incr;
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
5654 s->time= s->time_base*s->time_increment_resolution + time_increment;
745
25d7fb7c89be better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents: 718
diff changeset
5655 if(s->workaround_bugs&FF_BUG_UMP4){
700
0fb4c66527e1 autodetect UMP4 (by adding a fourcc field to AVCodecContext)
michaelni
parents: 699
diff changeset
5656 if(s->time < s->last_non_b_time){
0fb4c66527e1 autodetect UMP4 (by adding a fourcc field to AVCodecContext)
michaelni
parents: 699
diff changeset
5657 // fprintf(stderr, "header is not mpeg4 compatible, broken encoder, trying to workaround\n");
0fb4c66527e1 autodetect UMP4 (by adding a fourcc field to AVCodecContext)
michaelni
parents: 699
diff changeset
5658 s->time_base++;
0fb4c66527e1 autodetect UMP4 (by adding a fourcc field to AVCodecContext)
michaelni
parents: 699
diff changeset
5659 s->time+= s->time_increment_resolution;
0fb4c66527e1 autodetect UMP4 (by adding a fourcc field to AVCodecContext)
michaelni
parents: 699
diff changeset
5660 }
664
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
5661 }
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
5662 s->pp_time= s->time - s->last_non_b_time;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
5663 s->last_non_b_time= s->time;
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
5664 }else{
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 322
diff changeset
5665 s->time= (s->last_time_base + time_incr)*s->time_increment_resolution + time_increment;
664
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
5666 s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
5667 if(s->pp_time <=s->pb_time || s->pp_time <= s->pp_time - s->pb_time || s->pp_time<=0){
335
e7e9d9901523 b-frame mpeg4 fix when seeking
michaelni
parents: 333
diff changeset
5668 // printf("messed up order, seeking?, skiping current b frame\n");
e7e9d9901523 b-frame mpeg4 fix when seeking
michaelni
parents: 333
diff changeset
5669 return FRAME_SKIPED;
e7e9d9901523 b-frame mpeg4 fix when seeking
michaelni
parents: 333
diff changeset
5670 }
664
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
5671
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
5672 if(s->t_frame==0) s->t_frame= s->time - s->last_time_base;
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
5673 if(s->t_frame==0) s->t_frame=1; // 1/0 protection
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
5674 //printf("%Ld %Ld %d %d\n", s->last_non_b_time, s->time, s->pp_time, s->t_frame); fflush(stdout);
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
5675 s->pp_field_time= ( ROUNDED_DIV(s->last_non_b_time, s->t_frame)
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
5676 - ROUNDED_DIV(s->last_non_b_time - s->pp_time, s->t_frame))*2;
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
5677 s->pb_field_time= ( ROUNDED_DIV(s->time, s->t_frame)
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
5678 - ROUNDED_DIV(s->last_non_b_time - s->pp_time, s->t_frame))*2;
262
7d941b8c4e84 mpeg4 b-frames :)
michaelni
parents: 255
diff changeset
5679 }
654
850098147a3c export pts from stream if available
michaelni
parents: 648
diff changeset
5680
1586
3d1d0490e5a6 pts fix and related fixes
michael
parents: 1584
diff changeset
5681 s->current_picture_ptr->pts= s->time*1000LL*1000LL / s->time_increment_resolution;
942
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
5682 if(s->avctx->debug&FF_DEBUG_PTS)
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1586
diff changeset
5683 av_log(s->avctx, AV_LOG_DEBUG, "MPEG4 PTS: %f\n", s->current_picture_ptr->pts/(1000.0*1000.0));
654
850098147a3c export pts from stream if available
michaelni
parents: 648
diff changeset
5684
1068
a5be963709d1 improving parsing of incomplete headers
michaelni
parents: 1064
diff changeset
5685 check_marker(gb, "before vop_coded");
a5be963709d1 improving parsing of incomplete headers
michaelni
parents: 1064
diff changeset
5686
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
5687 /* vop coded */
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5688 if (get_bits1(gb) != 1){
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1586
diff changeset
5689 av_log(s->avctx, AV_LOG_ERROR, "vop not coded\n");
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5690 return FRAME_SKIPED;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5691 }
664
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
5692 //printf("time %d %d %d || %Ld %Ld %Ld\n", s->time_increment_bits, s->time_increment_resolution, s->time_base,
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 662
diff changeset
5693 //s->time, s->last_non_b_time, s->last_non_b_time - s->pp_time);
253
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
5694 if (s->shape != BIN_ONLY_SHAPE && ( s->pict_type == P_TYPE
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
5695 || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE))) {
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
5696 /* rounding type for motion estimation */
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5697 s->no_rounding = get_bits1(gb);
63
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
5698 } else {
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
5699 s->no_rounding = 0;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
5700 }
253
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
5701 //FIXME reduced res stuff
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
5702
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
5703 if (s->shape != RECT_SHAPE) {
63
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
5704 if (s->vol_sprite_usage != 1 || s->pict_type != I_TYPE) {
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
5705 int width, height, hor_spat_ref, ver_spat_ref;
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
5706
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5707 width = get_bits(gb, 13);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5708 skip_bits1(gb); /* marker */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5709 height = get_bits(gb, 13);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5710 skip_bits1(gb); /* marker */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5711 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
5712 skip_bits1(gb); /* marker */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5713 ver_spat_ref = get_bits(gb, 13); /* ver_spat_ref */
63
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
5714 }
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5715 skip_bits1(gb); /* change_CR_disable */
63
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
5716
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5717 if (get_bits1(gb) != 0) {
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5718 skip_bits(gb, 8); /* constant_alpha_value */
63
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
5719 }
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
5720 }
253
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
5721 //FIXME complexity estimation stuff
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
5722
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
5723 if (s->shape != BIN_ONLY_SHAPE) {
1520
ad5461bad820 intra dc treshold != 0 decoding fixed
michael
parents: 1512
diff changeset
5724 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
5725 if(!s->progressive_sequence){
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5726 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
5727 s->alternate_scan= get_bits1(gb);
661
a0901e38c564 fixing interlaced mpeg4 decoding
michaelni
parents: 660
diff changeset
5728 }else
a0901e38c564 fixing interlaced mpeg4 decoding
michaelni
parents: 660
diff changeset
5729 s->alternate_scan= 0;
253
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
5730 }
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
5731
718
16dab8296293 fixing custom quantizer matrix decoding
michaelni
parents: 706
diff changeset
5732 if(s->alternate_scan){
1273
a979fab41ed8 ASV1 codec
michaelni
parents: 1271
diff changeset
5733 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_alternate_vertical_scan);
a979fab41ed8 ASV1 codec
michaelni
parents: 1271
diff changeset
5734 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_alternate_vertical_scan);
a979fab41ed8 ASV1 codec
michaelni
parents: 1271
diff changeset
5735 ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_vertical_scan);
a979fab41ed8 ASV1 codec
michaelni
parents: 1271
diff changeset
5736 ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
718
16dab8296293 fixing custom quantizer matrix decoding
michaelni
parents: 706
diff changeset
5737 } else{
1273
a979fab41ed8 ASV1 codec
michaelni
parents: 1271
diff changeset
5738 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_zigzag_direct);
a979fab41ed8 ASV1 codec
michaelni
parents: 1271
diff changeset
5739 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_zigzag_direct);
a979fab41ed8 ASV1 codec
michaelni
parents: 1271
diff changeset
5740 ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
a979fab41ed8 ASV1 codec
michaelni
parents: 1271
diff changeset
5741 ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
718
16dab8296293 fixing custom quantizer matrix decoding
michaelni
parents: 706
diff changeset
5742 }
16dab8296293 fixing custom quantizer matrix decoding
michaelni
parents: 706
diff changeset
5743
253
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
5744 if(s->pict_type == S_TYPE && (s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE)){
821
f5f2e162331c hopefully fixing sprite_warping_points==0
michaelni
parents: 815
diff changeset
5745 mpeg4_decode_sprite_trajectory(s);
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1586
diff changeset
5746 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
5747 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
5748 }
254
b4fed8b24e3a gmc bitstream decoding support (the real motion compensation isnt implemnted yet)
michaelni
parents: 253
diff changeset
5749
253
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
5750 if (s->shape != BIN_ONLY_SHAPE) {
1644
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
5751 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
5752 if(s->qscale==0){
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1586
diff changeset
5753 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
5754 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
5755 }
63
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
5756
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
5757 if (s->pict_type != I_TYPE) {
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5758 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
5759 if(s->f_code==0){
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1586
diff changeset
5760 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
5761 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
5762 }
582
5132a4ee50cd different edge positions fixed with edge emu / dr1
michaelni
parents: 575
diff changeset
5763 }else
5132a4ee50cd different edge positions fixed with edge emu / dr1
michaelni
parents: 575
diff changeset
5764 s->f_code=1;
5132a4ee50cd different edge positions fixed with edge emu / dr1
michaelni
parents: 575
diff changeset
5765
253
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
5766 if (s->pict_type == B_TYPE) {
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5767 s->b_code = get_bits(gb, 3);
582
5132a4ee50cd different edge positions fixed with edge emu / dr1
michaelni
parents: 575
diff changeset
5768 }else
5132a4ee50cd different edge positions fixed with edge emu / dr1
michaelni
parents: 575
diff changeset
5769 s->b_code=1;
906
bbe0c99231a7 specific debug output support
michaelni
parents: 905
diff changeset
5770
bbe0c99231a7 specific debug output support
michaelni
parents: 905
diff changeset
5771 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
5772 av_log(s->avctx, AV_LOG_DEBUG, "qp:%d fc:%d,%d %s size:%d pro:%d alt:%d top:%d %spel part:%d resync:%d w:%d a:%d rnd:%d vot:%d%s dc:%d\n",
906
bbe0c99231a7 specific debug output support
michaelni
parents: 905
diff changeset
5773 s->qscale, s->f_code, s->b_code,
bbe0c99231a7 specific debug output support
michaelni
parents: 905
diff changeset
5774 s->pict_type == I_TYPE ? "I" : (s->pict_type == P_TYPE ? "P" : (s->pict_type == B_TYPE ? "B" : "S")),
1025
1f9afd8b9131 GetBitContext.size is allways multiplied by 8 -> use size_in_bits to avoid useless *8 in a few inner loops
michaelni
parents: 1013
diff changeset
5775 gb->size_in_bits,s->progressive_sequence, s->alternate_scan, s->top_field_first,
930
6bcb214d6a17 more debug output
michaelni
parents: 923
diff changeset
5776 s->quarter_sample ? "q" : "h", s->data_partitioning, s->resync_marker, s->num_sprite_warping_points,
1520
ad5461bad820 intra dc treshold != 0 decoding fixed
michael
parents: 1512
diff changeset
5777 s->sprite_warping_accuracy, 1-s->no_rounding, s->vo_type, s->vol_control_parameters ? " VOLC" : " ", s->intra_dc_threshold);
906
bbe0c99231a7 specific debug output support
michaelni
parents: 905
diff changeset
5778 }
bbe0c99231a7 specific debug output support
michaelni
parents: 905
diff changeset
5779
253
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
5780 if(!s->scalability){
4448dd55d415 parsing more of the mpeg4 header & print some "not supported" stuff
michaelni
parents: 250
diff changeset
5781 if (s->shape!=RECT_SHAPE && s->pict_type!=I_TYPE) {
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5782 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
5783 }
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
5784 }else{
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
5785 if(s->enhancement_type){
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5786 int load_backward_shape= get_bits1(gb);
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
5787 if(load_backward_shape){
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1586
diff changeset
5788 av_log(s->avctx, AV_LOG_ERROR, "load backward shape isnt supported\n");
575
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
5789 }
23eee7d73c4b minor optimizations
michaelni
parents: 564
diff changeset
5790 }
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5791 skip_bits(gb, 2); //ref_select_code
63
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
5792 }
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
5793 }
346
c2f789fe4945 detecting xvid/divx4/opendivx and set low_delay flag
michaelni
parents: 344
diff changeset
5794 /* detect buggy encoders which dont set the low_delay flag (divx4/xvid/opendivx)*/
c2f789fe4945 detecting xvid/divx4/opendivx and set low_delay flag
michaelni
parents: 344
diff changeset
5795 // note we cannot detect divx5 without b-frames easyly (allthough its buggy too)
365
fdeec2834c79 there are divx5? encoded files without a userdata section but with b-frames :(
michaelni
parents: 364
diff changeset
5796 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
5797 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
5798 s->low_delay=1;
c2f789fe4945 detecting xvid/divx4/opendivx and set low_delay flag
michaelni
parents: 344
diff changeset
5799 }
c2f789fe4945 detecting xvid/divx4/opendivx and set low_delay flag
michaelni
parents: 344
diff changeset
5800
255
db20b987c32d divx5-gmc support
michaelni
parents: 254
diff changeset
5801 s->picture_number++; // better than pic number==0 allways ;)
346
c2f789fe4945 detecting xvid/divx4/opendivx and set low_delay flag
michaelni
parents: 344
diff changeset
5802
498
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
5803 s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table; //FIXME add short header support
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
5804 s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
0b4450c15067 dc scale simplification/optimization
michaelni
parents: 482
diff changeset
5805
1366
80067f8d6770 fix edge repeating bug for %16!=0 files, this fixes Quicktime mpeg4 (they arent buggy)
michaelni
parents: 1364
diff changeset
5806 if(s->workaround_bugs&FF_BUG_EDGE){
582
5132a4ee50cd different edge positions fixed with edge emu / dr1
michaelni
parents: 575
diff changeset
5807 s->h_edge_pos= s->width;
5132a4ee50cd different edge positions fixed with edge emu / dr1
michaelni
parents: 575
diff changeset
5808 s->v_edge_pos= s->height;
5132a4ee50cd different edge positions fixed with edge emu / dr1
michaelni
parents: 575
diff changeset
5809 }
63
8e2d8dbf89a5 better vol header parsing for mpeg4
glantau
parents: 21
diff changeset
5810 return 0;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
5811 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
5812
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5813 /**
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5814 * decode mpeg4 headers
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5815 * @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
5816 * 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
5817 * 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
5818 */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5819 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
5820 {
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5821 int startcode, v;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5822
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5823 /* search next start code */
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5824 align_get_bits(gb);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5825 startcode = 0xff;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5826 for(;;) {
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5827 v = get_bits(gb, 8);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5828 startcode = ((startcode << 8) | v) & 0xffffffff;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5829
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
5830 if(get_bits_count(gb) >= gb->size_in_bits){
1f9afd8b9131 GetBitContext.size is allways multiplied by 8 -> use size_in_bits to avoid useless *8 in a few inner loops
michaelni
parents: 1013
diff changeset
5831 if(gb->size_in_bits==8 && s->divx_version){
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1586
diff changeset
5832 av_log(s->avctx, AV_LOG_ERROR, "frame skip %d\n", gb->size_in_bits);
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5833 return FRAME_SKIPED; //divx bug
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5834 }else
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5835 return -1; //end of stream
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 if((startcode&0xFFFFFF00) != 0x100)
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5839 continue; //no startcode
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5840
942
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
5841 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
5842 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
5843 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
5844 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
5845 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
5846 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
5847 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
5848 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
5849 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
5850 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
5851 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
5852 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
5853 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
5854 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
5855 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
5856 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
5857 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
5858 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
5859 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
5860 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
5861 else if(startcode==0x1BD) av_log(s->avctx, AV_LOG_DEBUG, "Mesh Object Plane start");
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1586
diff changeset
5862 else if(startcode==0x1BE) av_log(s->avctx, AV_LOG_DEBUG, "Still Textutre Object start");
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1586
diff changeset
5863 else if(startcode==0x1BF) av_log(s->avctx, AV_LOG_DEBUG, "Textutre Spatial Layer start");
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1586
diff changeset
5864 else if(startcode==0x1C0) av_log(s->avctx, AV_LOG_DEBUG, "Textutre SNR Layer start");
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1586
diff changeset
5865 else if(startcode==0x1C1) av_log(s->avctx, AV_LOG_DEBUG, "Textutre Tile start");
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1586
diff changeset
5866 else if(startcode==0x1C2) av_log(s->avctx, AV_LOG_DEBUG, "Textutre Shape Layer start");
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1586
diff changeset
5867 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
5868 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
5869 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
5870 av_log(s->avctx, AV_LOG_DEBUG, " at %d\n", get_bits_count(gb));
942
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
5871 }
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
5872
1512
e9f83c2323bf recommit of
michael
parents: 1505
diff changeset
5873 if(startcode >= 0x120 && startcode <= 0x12F){
1396
e380ac39024a cleanup / fixes
michaelni
parents: 1393
diff changeset
5874 if(decode_vol_header(s, gb) < 0)
e380ac39024a cleanup / fixes
michaelni
parents: 1393
diff changeset
5875 return -1;
1512
e9f83c2323bf recommit of
michael
parents: 1505
diff changeset
5876 }
e9f83c2323bf recommit of
michael
parents: 1505
diff changeset
5877 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
5878 decode_user_data(s, gb);
1512
e9f83c2323bf recommit of
michael
parents: 1505
diff changeset
5879 }
e9f83c2323bf recommit of
michael
parents: 1505
diff changeset
5880 else if(startcode == GOP_STARTCODE){
942
c237f5db1c22 correcter mpeg4 headers
michaelni
parents: 936
diff changeset
5881 mpeg4_decode_gop_header(s, gb);
1512
e9f83c2323bf recommit of
michael
parents: 1505
diff changeset
5882 }
e9f83c2323bf recommit of
michael
parents: 1505
diff changeset
5883 else if(startcode == VOP_STARTCODE){
747
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5884 return decode_vop_header(s, gb);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5885 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5886
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5887 align_get_bits(gb);
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5888 startcode = 0xff;
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5889 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5890 }
3d4377531f6c mpeg4 header parser clenup (needed for parsing of VOL header in avctx->extradata)
michaelni
parents: 745
diff changeset
5891
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
5892 /* don't understand why they choose a different header ! */
986e461dc072 Initial revision
glantau
parents:
diff changeset
5893 int intel_h263_decode_picture_header(MpegEncContext *s)
986e461dc072 Initial revision
glantau
parents:
diff changeset
5894 {
986e461dc072 Initial revision
glantau
parents:
diff changeset
5895 int format;
986e461dc072 Initial revision
glantau
parents:
diff changeset
5896
986e461dc072 Initial revision
glantau
parents:
diff changeset
5897 /* picture header */
1257
6defe392d5d2 libmpeg2 style bitstream reader fixes
michaelni
parents: 1255
diff changeset
5898 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
5899 av_log(s->avctx, AV_LOG_ERROR, "Bad picture start code\n");
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
5900 return -1;
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
5901 }
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
5902 s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
5903
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
5904 if (get_bits1(&s->gb) != 1) {
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1586
diff changeset
5905 av_log(s->avctx, AV_LOG_ERROR, "Bad marker\n");
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
5906 return -1; /* marker */
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
5907 }
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
5908 if (get_bits1(&s->gb) != 0) {
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1586
diff changeset
5909 av_log(s->avctx, AV_LOG_ERROR, "Bad H263 id\n");
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
5910 return -1; /* h263 id */
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
5911 }
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
5912 skip_bits1(&s->gb); /* split screen off */
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
5913 skip_bits1(&s->gb); /* camera off */
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
5914 skip_bits1(&s->gb); /* freeze picture release off */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
5915
986e461dc072 Initial revision
glantau
parents:
diff changeset
5916 format = get_bits(&s->gb, 3);
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
5917 if (format != 7) {
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1586
diff changeset
5918 av_log(s->avctx, AV_LOG_ERROR, "Intel H263 free format not supported\n");
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
5919 return -1;
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
5920 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
5921 s->h263_plus = 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
5922
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
5923 s->pict_type = I_TYPE + get_bits1(&s->gb);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
5924
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
5925 s->unrestricted_mv = get_bits1(&s->gb);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
5926 s->h263_long_vectors = s->unrestricted_mv;
986e461dc072 Initial revision
glantau
parents:
diff changeset
5927
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
5928 if (get_bits1(&s->gb) != 0) {
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1586
diff changeset
5929 av_log(s->avctx, AV_LOG_ERROR, "SAC not supported\n");
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
5930 return -1; /* SAC: off */
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
5931 }
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
5932 if (get_bits1(&s->gb) != 0) {
1633
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
5933 s->obmc= 1;
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1586
diff changeset
5934 av_log(s->avctx, AV_LOG_ERROR, "Advanced Prediction Mode not supported\n");
1633
27806cccec2a h263 OBMC & 4MV support
michael
parents: 1598
diff changeset
5935 // return -1; /* advanced prediction mode: off */
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
5936 }
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
5937 if (get_bits1(&s->gb) != 0) {
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1586
diff changeset
5938 av_log(s->avctx, AV_LOG_ERROR, "PB frame mode no supported\n");
355
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
5939 return -1; /* PB frame mode */
ac6fc4c7aecb - H263 PAR support by Alex Beregszaszi.
pulento
parents: 350
diff changeset
5940 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
5941
986e461dc072 Initial revision
glantau
parents:
diff changeset
5942 /* skip unknown header garbage */
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
5943 skip_bits(&s->gb, 41);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
5944
1644
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
5945 s->chroma_qscale= s->qscale = get_bits(&s->gb, 5);
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
5946 skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
5947
986e461dc072 Initial revision
glantau
parents:
diff changeset
5948 /* PEI */
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
5949 while (get_bits1(&s->gb) != 0) {
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 7
diff changeset
5950 skip_bits(&s->gb, 8);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
5951 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
5952 s->f_code = 1;
770
d1770a34e4f6 segfault fix patch by (Juergen Keil <jk at tools dot de>)
michaelni
parents: 766
diff changeset
5953
d1770a34e4f6 segfault fix patch by (Juergen Keil <jk at tools dot de>)
michaelni
parents: 766
diff changeset
5954 s->y_dc_scale_table=
d1770a34e4f6 segfault fix patch by (Juergen Keil <jk at tools dot de>)
michaelni
parents: 766
diff changeset
5955 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
5956
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
5957 return 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
5958 }
144
cb5dabd00ba2 - Bug fix on inter MCBPC table for inter+q.
pulento
parents: 110
diff changeset
5959
1353
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
5960 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
5961 {
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
5962 int format, width, height;
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
5963
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
5964 /* picture header */
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
5965 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
5966 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
5967 return -1;
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
5968 }
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
5969 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
5970 if (format != 0 && format != 1) {
1598
932d306bf1dc av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents: 1586
diff changeset
5971 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
5972 return -1;
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
5973 }
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
5974 s->h263_flv = format+1;
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
5975 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
5976 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
5977 switch (format) {
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
5978 case 0:
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
5979 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
5980 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
5981 break;
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
5982 case 1:
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
5983 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
5984 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
5985 break;
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
5986 case 2:
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
5987 width = 352;
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
5988 height = 288;
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
5989 break;
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
5990 case 3:
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
5991 width = 176;
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
5992 height = 144;
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
5993 break;
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
5994 case 4:
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
5995 width = 128;
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
5996 height = 96;
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
5997 break;
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
5998 case 5:
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
5999 width = 320;
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
6000 height = 240;
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
6001 break;
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
6002 case 6:
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
6003 width = 160;
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
6004 height = 120;
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
6005 break;
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
6006 default:
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
6007 width = height = 0;
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
6008 break;
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
6009 }
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
6010 if ((width == 0) || (height == 0))
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
6011 return -1;
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
6012 s->width = width;
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
6013 s->height = height;
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
6014
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
6015 s->pict_type = I_TYPE + get_bits(&s->gb, 2);
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
6016 if (s->pict_type > P_TYPE)
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
6017 s->pict_type = P_TYPE;
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
6018 skip_bits1(&s->gb); /* deblocking flag */
1644
835cf346975e h263 loop filter
michael
parents: 1641
diff changeset
6019 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
6020
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
6021 s->h263_plus = 0;
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
6022
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
6023 s->unrestricted_mv = 1;
1364
463090933f60 flv1 fix
michaelni
parents: 1356
diff changeset
6024 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
6025
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
6026 /* PEI */
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
6027 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
6028 skip_bits(&s->gb, 8);
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
6029 }
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
6030 s->f_code = 1;
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
6031
1364
463090933f60 flv1 fix
michaelni
parents: 1356
diff changeset
6032 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
6033 av_log(s->avctx, AV_LOG_DEBUG, "%c esc_type:%d, qp:%d num:%d\n",
1364
463090933f60 flv1 fix
michaelni
parents: 1356
diff changeset
6034 av_get_pict_type_char(s->pict_type), s->h263_flv-1, s->qscale, s->picture_number);
463090933f60 flv1 fix
michaelni
parents: 1356
diff changeset
6035 }
463090933f60 flv1 fix
michaelni
parents: 1356
diff changeset
6036
1353
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
6037 s->y_dc_scale_table=
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
6038 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
6039
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
6040 return 0;
cfc80b3a4ada flash video (flv) support patch by (Garrick Meeker <gmeeker at theoryllc dot com>)
michaelni
parents: 1350
diff changeset
6041 }