Mercurial > libavcodec.hg
annotate dv.c @ 3198:6b9f0c4fbdbe libavcodec
First part of a series of speed-enchancing patches.
This one sets up a snow.h and makes snow use the dsputil function pointer
framework to access the three functions that will be implemented in asm
in the other parts of the patchset.
Patch by Robert Edele < yartrebo AH earthlink POIS net>
Original thread:
Subject: [Ffmpeg-devel] [PATCH] Snow mmx+sse2 asm optimizations
Date: Sun, 05 Feb 2006 12:47:14 -0500
author | gpoirier |
---|---|
date | Thu, 16 Mar 2006 19:18:18 +0000 |
parents | 1deaaa111fbc |
children | 3335f51b6cd3 |
rev | line source |
---|---|
723 | 1 /* |
2 * DV decoder | |
3 * Copyright (c) 2002 Fabrice Bellard. | |
1905
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
4 * Copyright (c) 2004 Roman Shaposhnik. |
723 | 5 * |
2967 | 6 * DV encoder |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
7 * Copyright (c) 2003 Roman Shaposhnik. |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
8 * |
3167 | 9 * 50 Mbps (DVCPRO50) support |
10 * Copyright (c) 2006 Daniel Maas <dmaas@maasdigital.com> | |
11 * | |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
12 * Many thanks to Dan Dennedy <dan@dennedy.org> for providing wealth |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
13 * of DV technical info. |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
14 * |
723 | 15 * This library is free software; you can redistribute it and/or |
16 * modify it under the terms of the GNU Lesser General Public | |
17 * License as published by the Free Software Foundation; either | |
18 * version 2 of the License, or (at your option) any later version. | |
19 * | |
20 * This library is distributed in the hope that it will be useful, | |
21 * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
22 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
23 * Lesser General Public License for more details. | |
24 * | |
25 * You should have received a copy of the GNU Lesser General Public | |
26 * License along with this library; if not, write to the Free Software | |
3036
0b546eab515d
Update licensing information: The FSF changed postal address.
diego
parents:
3016
diff
changeset
|
27 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
723 | 28 */ |
1106 | 29 |
30 /** | |
31 * @file dv.c | |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
32 * DV codec. |
1106 | 33 */ |
723 | 34 #include "avcodec.h" |
35 #include "dsputil.h" | |
36 #include "mpegvideo.h" | |
37 #include "simple_idct.h" | |
1489
337d13aee605
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
1416
diff
changeset
|
38 #include "dvdata.h" |
723 | 39 |
2847 | 40 //#undef NDEBUG |
41 //#include <assert.h> | |
42 | |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
43 typedef struct DVVideoContext { |
1489
337d13aee605
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
1416
diff
changeset
|
44 const DVprofile* sys; |
925 | 45 AVFrame picture; |
2847 | 46 AVCodecContext *avctx; |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
47 uint8_t *buf; |
2967 | 48 |
1064 | 49 uint8_t dv_zigzag[2][64]; |
1905
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
50 uint8_t dv_idct_shift[2][2][22][64]; |
2967 | 51 |
1489
337d13aee605
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
1416
diff
changeset
|
52 void (*get_pixels)(DCTELEM *block, const uint8_t *pixels, int line_size); |
1567 | 53 void (*fdct[2])(DCTELEM *block); |
54 void (*idct_put[2])(uint8_t *dest, int line_size, DCTELEM *block); | |
3016
97e6c0f82182
Moving dv_anchor back to the global scope. This creates a tiny memory
romansh
parents:
2991
diff
changeset
|
55 } DVVideoContext; |
2991
d377b0788381
Fix DV memory leak and allow multiple instances patch by (Burkhard Plaum?)
michael
parents:
2979
diff
changeset
|
56 |
3167 | 57 /* MultiThreading - dv_anchor applies to entire DV codec, not just the avcontext */ |
58 /* one element is needed for each video segment in a DV frame */ | |
59 /* at most there are 2 DIF channels * 12 DIF sequences * 27 video segments (PAL 50Mbps) */ | |
60 #define DV_ANCHOR_SIZE (2*12*27) | |
61 | |
62 static void* dv_anchor[DV_ANCHOR_SIZE]; | |
723 | 63 |
1489
337d13aee605
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
1416
diff
changeset
|
64 #define TEX_VLC_BITS 9 |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
65 |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
66 #ifdef DV_CODEC_TINY_TARGET |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
67 #define DV_VLC_MAP_RUN_SIZE 15 |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
68 #define DV_VLC_MAP_LEV_SIZE 23 |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
69 #else |
2967 | 70 #define DV_VLC_MAP_RUN_SIZE 64 |
2847 | 71 #define DV_VLC_MAP_LEV_SIZE 512 //FIXME sign was removed so this should be /2 but needs check |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
72 #endif |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
73 |
723 | 74 /* XXX: also include quantization */ |
1886
fbcf02596520
* DV decoder simplifications. Now it looks to be 6% faster. At least
romansh
parents:
1875
diff
changeset
|
75 static RL_VLC_ELEM *dv_rl_vlc; |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
76 /* VLC encoding lookup table */ |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
77 static struct dv_vlc_pair { |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
78 uint32_t vlc; |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
79 uint8_t size; |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
80 } (*dv_vlc_map)[DV_VLC_MAP_LEV_SIZE] = NULL; |
723 | 81 |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
82 static void dv_build_unquantize_tables(DVVideoContext *s, uint8_t* perm) |
723 | 83 { |
725 | 84 int i, q, j; |
723 | 85 |
86 /* NOTE: max left shift is 6 */ | |
725 | 87 for(q = 0; q < 22; q++) { |
1567 | 88 /* 88DCT */ |
725 | 89 for(i = 1; i < 64; i++) { |
90 /* 88 table */ | |
1567 | 91 j = perm[i]; |
1905
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
92 s->dv_idct_shift[0][0][q][j] = |
725 | 93 dv_quant_shifts[q][dv_88_areas[i]] + 1; |
2979 | 94 s->dv_idct_shift[1][0][q][j] = s->dv_idct_shift[0][0][q][j] + 1; |
725 | 95 } |
2967 | 96 |
1567 | 97 /* 248DCT */ |
725 | 98 for(i = 1; i < 64; i++) { |
99 /* 248 table */ | |
2967 | 100 s->dv_idct_shift[0][1][q][i] = |
1567 | 101 dv_quant_shifts[q][dv_248_areas[i]] + 1; |
2979 | 102 s->dv_idct_shift[1][1][q][i] = s->dv_idct_shift[0][1][q][i] + 1; |
723 | 103 } |
104 } | |
105 } | |
106 | |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
107 static int dvvideo_init(AVCodecContext *avctx) |
723 | 108 { |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
109 DVVideoContext *s = avctx->priv_data; |
1567 | 110 DSPContext dsp; |
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:
1064
diff
changeset
|
111 static int done=0; |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
112 int i, j; |
723 | 113 |
114 if (!done) { | |
1489
337d13aee605
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
1416
diff
changeset
|
115 VLC dv_vlc; |
1905
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
116 uint16_t new_dv_vlc_bits[NB_DV_VLC*2]; |
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
117 uint8_t new_dv_vlc_len[NB_DV_VLC*2]; |
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
118 uint8_t new_dv_vlc_run[NB_DV_VLC*2]; |
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
119 int16_t new_dv_vlc_level[NB_DV_VLC*2]; |
723 | 120 |
121 done = 1; | |
122 | |
2845
d9f4b93e81c5
Fix for memleak in dv.c patch by (Burkhard Plaum; plaum, ipf uni-stuttgart de)
michael
parents:
2822
diff
changeset
|
123 dv_vlc_map = av_mallocz_static(DV_VLC_MAP_LEV_SIZE*DV_VLC_MAP_RUN_SIZE*sizeof(struct dv_vlc_pair)); |
2979 | 124 if (!dv_vlc_map) |
125 return -ENOMEM; | |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
126 |
2979 | 127 /* dv_anchor lets each thread know its Id */ |
3167 | 128 for (i=0; i<DV_ANCHOR_SIZE; i++) |
3016
97e6c0f82182
Moving dv_anchor back to the global scope. This creates a tiny memory
romansh
parents:
2991
diff
changeset
|
129 dv_anchor[i] = (void*)(size_t)i; |
1905
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
130 |
2979 | 131 /* it's faster to include sign bit in a generic VLC parsing scheme */ |
132 for (i=0, j=0; i<NB_DV_VLC; i++, j++) { | |
133 new_dv_vlc_bits[j] = dv_vlc_bits[i]; | |
134 new_dv_vlc_len[j] = dv_vlc_len[i]; | |
135 new_dv_vlc_run[j] = dv_vlc_run[i]; | |
136 new_dv_vlc_level[j] = dv_vlc_level[i]; | |
2967 | 137 |
2979 | 138 if (dv_vlc_level[i]) { |
139 new_dv_vlc_bits[j] <<= 1; | |
140 new_dv_vlc_len[j]++; | |
1905
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
141 |
2979 | 142 j++; |
143 new_dv_vlc_bits[j] = (dv_vlc_bits[i] << 1) | 1; | |
144 new_dv_vlc_len[j] = dv_vlc_len[i] + 1; | |
145 new_dv_vlc_run[j] = dv_vlc_run[i]; | |
146 new_dv_vlc_level[j] = -dv_vlc_level[i]; | |
147 } | |
148 } | |
2967 | 149 |
723 | 150 /* NOTE: as a trick, we use the fact the no codes are unused |
151 to accelerate the parsing of partial codes */ | |
2967 | 152 init_vlc(&dv_vlc, TEX_VLC_BITS, j, |
2370
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2247
diff
changeset
|
153 new_dv_vlc_len, 1, 1, new_dv_vlc_bits, 2, 2, 0); |
723 | 154 |
2991
d377b0788381
Fix DV memory leak and allow multiple instances patch by (Burkhard Plaum?)
michael
parents:
2979
diff
changeset
|
155 dv_rl_vlc = av_mallocz_static(dv_vlc.table_size * sizeof(RL_VLC_ELEM)); |
3016
97e6c0f82182
Moving dv_anchor back to the global scope. This creates a tiny memory
romansh
parents:
2991
diff
changeset
|
156 if (!dv_rl_vlc) |
2979 | 157 return -ENOMEM; |
3016
97e6c0f82182
Moving dv_anchor back to the global scope. This creates a tiny memory
romansh
parents:
2991
diff
changeset
|
158 |
723 | 159 for(i = 0; i < dv_vlc.table_size; i++){ |
160 int code= dv_vlc.table[i][0]; | |
161 int len = dv_vlc.table[i][1]; | |
162 int level, run; | |
2967 | 163 |
723 | 164 if(len<0){ //more bits needed |
165 run= 0; | |
166 level= code; | |
167 } else { | |
1905
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
168 run= new_dv_vlc_run[code] + 1; |
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
169 level= new_dv_vlc_level[code]; |
723 | 170 } |
1886
fbcf02596520
* DV decoder simplifications. Now it looks to be 6% faster. At least
romansh
parents:
1875
diff
changeset
|
171 dv_rl_vlc[i].len = len; |
fbcf02596520
* DV decoder simplifications. Now it looks to be 6% faster. At least
romansh
parents:
1875
diff
changeset
|
172 dv_rl_vlc[i].level = level; |
fbcf02596520
* DV decoder simplifications. Now it looks to be 6% faster. At least
romansh
parents:
1875
diff
changeset
|
173 dv_rl_vlc[i].run = run; |
723 | 174 } |
2979 | 175 free_vlc(&dv_vlc); |
1489
337d13aee605
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
1416
diff
changeset
|
176 |
2979 | 177 for (i = 0; i < NB_DV_VLC - 1; i++) { |
2027
3a78447c3b53
oops, forgot to commit that change from the warning fixes by (Michael Roitzsch <mroi at users dot sourceforge dot net>)
michael
parents:
1994
diff
changeset
|
178 if (dv_vlc_run[i] >= DV_VLC_MAP_RUN_SIZE) |
2979 | 179 continue; |
2027
3a78447c3b53
oops, forgot to commit that change from the warning fixes by (Michael Roitzsch <mroi at users dot sourceforge dot net>)
michael
parents:
1994
diff
changeset
|
180 #ifdef DV_CODEC_TINY_TARGET |
3a78447c3b53
oops, forgot to commit that change from the warning fixes by (Michael Roitzsch <mroi at users dot sourceforge dot net>)
michael
parents:
1994
diff
changeset
|
181 if (dv_vlc_level[i] >= DV_VLC_MAP_LEV_SIZE) |
2979 | 182 continue; |
2027
3a78447c3b53
oops, forgot to commit that change from the warning fixes by (Michael Roitzsch <mroi at users dot sourceforge dot net>)
michael
parents:
1994
diff
changeset
|
183 #endif |
2967 | 184 |
2979 | 185 if (dv_vlc_map[dv_vlc_run[i]][dv_vlc_level[i]].size != 0) |
186 continue; | |
2967 | 187 |
2979 | 188 dv_vlc_map[dv_vlc_run[i]][dv_vlc_level[i]].vlc = dv_vlc_bits[i] << |
189 (!!dv_vlc_level[i]); | |
190 dv_vlc_map[dv_vlc_run[i]][dv_vlc_level[i]].size = dv_vlc_len[i] + | |
191 (!!dv_vlc_level[i]); | |
192 } | |
193 for (i = 0; i < DV_VLC_MAP_RUN_SIZE; i++) { | |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
194 #ifdef DV_CODEC_TINY_TARGET |
2979 | 195 for (j = 1; j < DV_VLC_MAP_LEV_SIZE; j++) { |
196 if (dv_vlc_map[i][j].size == 0) { | |
197 dv_vlc_map[i][j].vlc = dv_vlc_map[0][j].vlc | | |
198 (dv_vlc_map[i-1][0].vlc << (dv_vlc_map[0][j].size)); | |
199 dv_vlc_map[i][j].size = dv_vlc_map[i-1][0].size + | |
200 dv_vlc_map[0][j].size; | |
201 } | |
202 } | |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
203 #else |
2979 | 204 for (j = 1; j < DV_VLC_MAP_LEV_SIZE/2; j++) { |
205 if (dv_vlc_map[i][j].size == 0) { | |
206 dv_vlc_map[i][j].vlc = dv_vlc_map[0][j].vlc | | |
207 (dv_vlc_map[i-1][0].vlc << (dv_vlc_map[0][j].size)); | |
208 dv_vlc_map[i][j].size = dv_vlc_map[i-1][0].size + | |
209 dv_vlc_map[0][j].size; | |
210 } | |
211 dv_vlc_map[i][((uint16_t)(-j))&0x1ff].vlc = | |
212 dv_vlc_map[i][j].vlc | 1; | |
213 dv_vlc_map[i][((uint16_t)(-j))&0x1ff].size = | |
214 dv_vlc_map[i][j].size; | |
215 } | |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
216 #endif |
2979 | 217 } |
723 | 218 } |
725 | 219 |
1567 | 220 /* Generic DSP setup */ |
221 dsputil_init(&dsp, avctx); | |
222 s->get_pixels = dsp.get_pixels; | |
725 | 223 |
1567 | 224 /* 88DCT setup */ |
225 s->fdct[0] = dsp.fdct; | |
226 s->idct_put[0] = dsp.idct_put; | |
227 for (i=0; i<64; i++) | |
228 s->dv_zigzag[0][i] = dsp.idct_permutation[ff_zigzag_direct[i]]; | |
725 | 229 |
1567 | 230 /* 248DCT setup */ |
231 s->fdct[1] = dsp.fdct248; | |
232 s->idct_put[1] = simple_idct248_put; // FIXME: need to add it to DSP | |
2849 | 233 if(avctx->lowres){ |
234 for (i=0; i<64; i++){ | |
235 int j= ff_zigzag248_direct[i]; | |
236 s->dv_zigzag[1][i] = dsp.idct_permutation[(j&7) + (j&8)*4 + (j&48)/2]; | |
237 } | |
238 }else | |
239 memcpy(s->dv_zigzag[1], ff_zigzag248_direct, 64); | |
725 | 240 |
723 | 241 /* XXX: do it only for constant case */ |
1567 | 242 dv_build_unquantize_tables(s, dsp.idct_permutation); |
1489
337d13aee605
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
1416
diff
changeset
|
243 |
1543
7542cb99b950
* providing MPEG codecs with a generic fields in AVFrame to use.
romansh
parents:
1540
diff
changeset
|
244 avctx->coded_frame = &s->picture; |
2847 | 245 s->avctx= avctx; |
2967 | 246 |
723 | 247 return 0; |
248 } | |
249 | |
1489
337d13aee605
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
1416
diff
changeset
|
250 // #define VLC_DEBUG |
1905
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
251 // #define printf(...) av_log(NULL, AV_LOG_ERROR, __VA_ARGS__) |
723 | 252 |
725 | 253 typedef struct BlockInfo { |
1064 | 254 const uint8_t *shift_table; |
255 const uint8_t *scan_table; | |
3149
2679184e8be0
AC coefficient weighing (per SMPTE 314M) for the DV encoder and decoder. The
romansh
parents:
3148
diff
changeset
|
256 const int *iweight_table; |
1064 | 257 uint8_t pos; /* position in block */ |
258 uint8_t dct_mode; | |
259 uint8_t partial_bit_count; | |
260 uint16_t partial_bit_buffer; | |
725 | 261 int shift_offset; |
262 } BlockInfo; | |
723 | 263 |
264 /* block size in bits */ | |
1064 | 265 static const uint16_t block_sizes[6] = { |
723 | 266 112, 112, 112, 112, 80, 80 |
267 }; | |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
268 /* bit budget for AC only in 5 MBs */ |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
269 static const int vs_total_ac_bits = (100 * 4 + 68*2) * 5; |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
270 /* see dv_88_areas and dv_248_areas for details */ |
2967 | 271 static const int mb_area_start[5] = { 1, 6, 21, 43, 64 }; |
723 | 272 |
273 #ifndef ALT_BITSTREAM_READER | |
1256
b8e1c17b8d7d
some libmpeg2 style bitstream reader fixes (no dv doesnt yet work with it)
michaelni
parents:
1228
diff
changeset
|
274 #warning only works with ALT_BITSTREAM_READER |
2614
5e24800ab329
various fixes related to the non alt_bitstream_reader
michael
parents:
2453
diff
changeset
|
275 static int re_index; //Hack to make it compile |
723 | 276 #endif |
277 | |
1895
e5687117cc7f
* removing casualties of battle of the wits and English language
romansh
parents:
1887
diff
changeset
|
278 static inline int get_bits_left(GetBitContext *s) |
e5687117cc7f
* removing casualties of battle of the wits and English language
romansh
parents:
1887
diff
changeset
|
279 { |
e5687117cc7f
* removing casualties of battle of the wits and English language
romansh
parents:
1887
diff
changeset
|
280 return s->size_in_bits - get_bits_count(s); |
e5687117cc7f
* removing casualties of battle of the wits and English language
romansh
parents:
1887
diff
changeset
|
281 } |
e5687117cc7f
* removing casualties of battle of the wits and English language
romansh
parents:
1887
diff
changeset
|
282 |
e5687117cc7f
* removing casualties of battle of the wits and English language
romansh
parents:
1887
diff
changeset
|
283 static inline int get_bits_size(GetBitContext *s) |
e5687117cc7f
* removing casualties of battle of the wits and English language
romansh
parents:
1887
diff
changeset
|
284 { |
e5687117cc7f
* removing casualties of battle of the wits and English language
romansh
parents:
1887
diff
changeset
|
285 return s->size_in_bits; |
e5687117cc7f
* removing casualties of battle of the wits and English language
romansh
parents:
1887
diff
changeset
|
286 } |
e5687117cc7f
* removing casualties of battle of the wits and English language
romansh
parents:
1887
diff
changeset
|
287 |
e5687117cc7f
* removing casualties of battle of the wits and English language
romansh
parents:
1887
diff
changeset
|
288 static inline int put_bits_left(PutBitContext* s) |
e5687117cc7f
* removing casualties of battle of the wits and English language
romansh
parents:
1887
diff
changeset
|
289 { |
e5687117cc7f
* removing casualties of battle of the wits and English language
romansh
parents:
1887
diff
changeset
|
290 return (s->buf_end - s->buf) * 8 - put_bits_count(s); |
e5687117cc7f
* removing casualties of battle of the wits and English language
romansh
parents:
1887
diff
changeset
|
291 } |
e5687117cc7f
* removing casualties of battle of the wits and English language
romansh
parents:
1887
diff
changeset
|
292 |
723 | 293 /* decode ac coefs */ |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
294 static void dv_decode_ac(GetBitContext *gb, BlockInfo *mb, DCTELEM *block) |
723 | 295 { |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
296 int last_index = get_bits_size(gb); |
1064 | 297 const uint8_t *scan_table = mb->scan_table; |
298 const uint8_t *shift_table = mb->shift_table; | |
3149
2679184e8be0
AC coefficient weighing (per SMPTE 314M) for the DV encoder and decoder. The
romansh
parents:
3148
diff
changeset
|
299 const int *iweight_table = mb->iweight_table; |
725 | 300 int pos = mb->pos; |
1905
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
301 int partial_bit_count = mb->partial_bit_count; |
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
302 int level, pos1, run, vlc_len, index; |
2967 | 303 |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
304 OPEN_READER(re, gb); |
1905
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
305 UPDATE_CACHE(re, gb); |
2967 | 306 |
723 | 307 /* if we must parse a partial vlc, we do it here */ |
308 if (partial_bit_count > 0) { | |
1905
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
309 re_cache = ((unsigned)re_cache >> partial_bit_count) | |
2979 | 310 (mb->partial_bit_buffer << (sizeof(re_cache)*8 - partial_bit_count)); |
311 re_index -= partial_bit_count; | |
312 mb->partial_bit_count = 0; | |
723 | 313 } |
314 | |
315 /* get the AC coefficients until last_index is reached */ | |
316 for(;;) { | |
317 #ifdef VLC_DEBUG | |
1905
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
318 printf("%2d: bits=%04x index=%d\n", pos, SHOW_UBITS(re, gb, 16), re_index); |
723 | 319 #endif |
1905
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
320 /* our own optimized GET_RL_VLC */ |
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
321 index = NEG_USR32(re_cache, TEX_VLC_BITS); |
2979 | 322 vlc_len = dv_rl_vlc[index].len; |
1905
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
323 if (vlc_len < 0) { |
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
324 index = NEG_USR32((unsigned)re_cache << TEX_VLC_BITS, -vlc_len) + dv_rl_vlc[index].level; |
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
325 vlc_len = TEX_VLC_BITS - vlc_len; |
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
326 } |
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
327 level = dv_rl_vlc[index].level; |
2979 | 328 run = dv_rl_vlc[index].run; |
2967 | 329 |
2979 | 330 /* gotta check if we're still within gb boundaries */ |
331 if (re_index + vlc_len > last_index) { | |
332 /* should be < 16 bits otherwise a codeword could have been parsed */ | |
333 mb->partial_bit_count = last_index - re_index; | |
334 mb->partial_bit_buffer = NEG_USR32(re_cache, mb->partial_bit_count); | |
335 re_index = last_index; | |
336 break; | |
337 } | |
338 re_index += vlc_len; | |
1905
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
339 |
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
340 #ifdef VLC_DEBUG |
2979 | 341 printf("run=%d level=%d\n", run, level); |
1905
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
342 #endif |
2979 | 343 pos += run; |
344 if (pos >= 64) | |
345 break; | |
2967 | 346 |
2847 | 347 pos1 = scan_table[pos]; |
3149
2679184e8be0
AC coefficient weighing (per SMPTE 314M) for the DV encoder and decoder. The
romansh
parents:
3148
diff
changeset
|
348 level <<= shift_table[pos1]; |
2679184e8be0
AC coefficient weighing (per SMPTE 314M) for the DV encoder and decoder. The
romansh
parents:
3148
diff
changeset
|
349 |
2679184e8be0
AC coefficient weighing (per SMPTE 314M) for the DV encoder and decoder. The
romansh
parents:
3148
diff
changeset
|
350 /* unweigh, round, and shift down */ |
2679184e8be0
AC coefficient weighing (per SMPTE 314M) for the DV encoder and decoder. The
romansh
parents:
3148
diff
changeset
|
351 level = (level*iweight_table[pos] + (1 << (dv_iweight_bits-1))) >> dv_iweight_bits; |
2679184e8be0
AC coefficient weighing (per SMPTE 314M) for the DV encoder and decoder. The
romansh
parents:
3148
diff
changeset
|
352 |
2679184e8be0
AC coefficient weighing (per SMPTE 314M) for the DV encoder and decoder. The
romansh
parents:
3148
diff
changeset
|
353 block[pos1] = level; |
1905
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
354 |
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
355 UPDATE_CACHE(re, gb); |
723 | 356 } |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
357 CLOSE_READER(re, gb); |
725 | 358 mb->pos = pos; |
723 | 359 } |
360 | |
1886
fbcf02596520
* DV decoder simplifications. Now it looks to be 6% faster. At least
romansh
parents:
1875
diff
changeset
|
361 static inline void bit_copy(PutBitContext *pb, GetBitContext *gb) |
723 | 362 { |
1886
fbcf02596520
* DV decoder simplifications. Now it looks to be 6% faster. At least
romansh
parents:
1875
diff
changeset
|
363 int bits_left = get_bits_left(gb); |
2847 | 364 while (bits_left >= MIN_CACHE_BITS) { |
365 put_bits(pb, MIN_CACHE_BITS, get_bits(gb, MIN_CACHE_BITS)); | |
366 bits_left -= MIN_CACHE_BITS; | |
723 | 367 } |
368 if (bits_left > 0) { | |
369 put_bits(pb, bits_left, get_bits(gb, bits_left)); | |
370 } | |
371 } | |
372 | |
373 /* mb_x and mb_y are in units of 8 pixels */ | |
2967 | 374 static inline void dv_decode_video_segment(DVVideoContext *s, |
375 uint8_t *buf_ptr1, | |
1064 | 376 const uint16_t *mb_pos_ptr) |
723 | 377 { |
378 int quant, dc, dct_mode, class1, j; | |
379 int mb_index, mb_x, mb_y, v, last_index; | |
380 DCTELEM *block, *block1; | |
1886
fbcf02596520
* DV decoder simplifications. Now it looks to be 6% faster. At least
romansh
parents:
1875
diff
changeset
|
381 int c_offset; |
1064 | 382 uint8_t *y_ptr; |
383 void (*idct_put)(uint8_t *dest, int line_size, DCTELEM *block); | |
384 uint8_t *buf_ptr; | |
723 | 385 PutBitContext pb, vs_pb; |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
386 GetBitContext gb; |
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
387 BlockInfo mb_data[5 * 6], *mb, *mb1; |
3089 | 388 DECLARE_ALIGNED_8(DCTELEM, sblock[5*6][64]); |
389 DECLARE_ALIGNED_8(uint8_t, mb_bit_buffer[80 + 4]); /* allow some slack */ | |
390 DECLARE_ALIGNED_8(uint8_t, vs_bit_buffer[5 * 80 + 4]); /* allow some slack */ | |
2849 | 391 const int log2_blocksize= 3-s->avctx->lowres; |
2967 | 392 |
2847 | 393 assert((((int)mb_bit_buffer)&7)==0); |
394 assert((((int)vs_bit_buffer)&7)==0); | |
2967 | 395 |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
396 memset(sblock, 0, sizeof(sblock)); |
723 | 397 |
398 /* pass 1 : read DC and AC coefficients in blocks */ | |
399 buf_ptr = buf_ptr1; | |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
400 block1 = &sblock[0][0]; |
725 | 401 mb1 = mb_data; |
1522
79dddc5cd990
removed the obsolete and unused parameters of init_put_bits
alex
parents:
1507
diff
changeset
|
402 init_put_bits(&vs_pb, vs_bit_buffer, 5 * 80); |
1886
fbcf02596520
* DV decoder simplifications. Now it looks to be 6% faster. At least
romansh
parents:
1875
diff
changeset
|
403 for(mb_index = 0; mb_index < 5; mb_index++, mb1 += 6, block1 += 6 * 64) { |
723 | 404 /* skip header */ |
405 quant = buf_ptr[3] & 0x0f; | |
406 buf_ptr += 4; | |
1522
79dddc5cd990
removed the obsolete and unused parameters of init_put_bits
alex
parents:
1507
diff
changeset
|
407 init_put_bits(&pb, mb_bit_buffer, 80); |
725 | 408 mb = mb1; |
723 | 409 block = block1; |
410 for(j = 0;j < 6; j++) { | |
1886
fbcf02596520
* DV decoder simplifications. Now it looks to be 6% faster. At least
romansh
parents:
1875
diff
changeset
|
411 last_index = block_sizes[j]; |
2979 | 412 init_get_bits(&gb, buf_ptr, last_index); |
2967 | 413 |
723 | 414 /* get the dc */ |
2247 | 415 dc = get_sbits(&gb, 9); |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
416 dct_mode = get_bits1(&gb); |
725 | 417 mb->dct_mode = dct_mode; |
418 mb->scan_table = s->dv_zigzag[dct_mode]; | |
3149
2679184e8be0
AC coefficient weighing (per SMPTE 314M) for the DV encoder and decoder. The
romansh
parents:
3148
diff
changeset
|
419 mb->iweight_table = dct_mode ? dv_iweight_248 : dv_iweight_88; |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
420 class1 = get_bits(&gb, 2); |
1905
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
421 mb->shift_table = s->dv_idct_shift[class1 == 3][dct_mode] |
723 | 422 [quant + dv_quant_offset[class1]]; |
423 dc = dc << 2; | |
424 /* convert to unsigned because 128 is not added in the | |
425 standard IDCT */ | |
426 dc += 1024; | |
427 block[0] = dc; | |
428 buf_ptr += last_index >> 3; | |
725 | 429 mb->pos = 0; |
430 mb->partial_bit_count = 0; | |
723 | 431 |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
432 #ifdef VLC_DEBUG |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
433 printf("MB block: %d, %d ", mb_index, j); |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
434 #endif |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
435 dv_decode_ac(&gb, mb, block); |
723 | 436 |
437 /* write the remaining bits in a new buffer only if the | |
438 block is finished */ | |
1886
fbcf02596520
* DV decoder simplifications. Now it looks to be 6% faster. At least
romansh
parents:
1875
diff
changeset
|
439 if (mb->pos >= 64) |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
440 bit_copy(&pb, &gb); |
2967 | 441 |
723 | 442 block += 64; |
725 | 443 mb++; |
723 | 444 } |
2967 | 445 |
723 | 446 /* pass 2 : we can do it just after */ |
447 #ifdef VLC_DEBUG | |
1886
fbcf02596520
* DV decoder simplifications. Now it looks to be 6% faster. At least
romansh
parents:
1875
diff
changeset
|
448 printf("***pass 2 size=%d MB#=%d\n", put_bits_count(&pb), mb_index); |
723 | 449 #endif |
450 block = block1; | |
725 | 451 mb = mb1; |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
452 init_get_bits(&gb, mb_bit_buffer, put_bits_count(&pb)); |
2979 | 453 flush_put_bits(&pb); |
1886
fbcf02596520
* DV decoder simplifications. Now it looks to be 6% faster. At least
romansh
parents:
1875
diff
changeset
|
454 for(j = 0;j < 6; j++, block += 64, mb++) { |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
455 if (mb->pos < 64 && get_bits_left(&gb) > 0) { |
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
456 dv_decode_ac(&gb, mb, block); |
723 | 457 /* if still not finished, no need to parse other blocks */ |
1886
fbcf02596520
* DV decoder simplifications. Now it looks to be 6% faster. At least
romansh
parents:
1875
diff
changeset
|
458 if (mb->pos < 64) |
fbcf02596520
* DV decoder simplifications. Now it looks to be 6% faster. At least
romansh
parents:
1875
diff
changeset
|
459 break; |
723 | 460 } |
461 } | |
462 /* all blocks are finished, so the extra bytes can be used at | |
463 the video segment level */ | |
1886
fbcf02596520
* DV decoder simplifications. Now it looks to be 6% faster. At least
romansh
parents:
1875
diff
changeset
|
464 if (j >= 6) |
2979 | 465 bit_copy(&vs_pb, &gb); |
723 | 466 } |
467 | |
468 /* we need a pass other the whole video segment */ | |
469 #ifdef VLC_DEBUG | |
1886
fbcf02596520
* DV decoder simplifications. Now it looks to be 6% faster. At least
romansh
parents:
1875
diff
changeset
|
470 printf("***pass 3 size=%d\n", put_bits_count(&vs_pb)); |
723 | 471 #endif |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
472 block = &sblock[0][0]; |
723 | 473 mb = mb_data; |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
474 init_get_bits(&gb, vs_bit_buffer, put_bits_count(&vs_pb)); |
1886
fbcf02596520
* DV decoder simplifications. Now it looks to be 6% faster. At least
romansh
parents:
1875
diff
changeset
|
475 flush_put_bits(&vs_pb); |
723 | 476 for(mb_index = 0; mb_index < 5; mb_index++) { |
477 for(j = 0;j < 6; j++) { | |
1886
fbcf02596520
* DV decoder simplifications. Now it looks to be 6% faster. At least
romansh
parents:
1875
diff
changeset
|
478 if (mb->pos < 64) { |
723 | 479 #ifdef VLC_DEBUG |
480 printf("start %d:%d\n", mb_index, j); | |
481 #endif | |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
482 dv_decode_ac(&gb, mb, block); |
723 | 483 } |
2979 | 484 if (mb->pos >= 64 && mb->pos < 127) |
485 av_log(NULL, AV_LOG_ERROR, "AC EOB marker is absent pos=%d\n", mb->pos); | |
723 | 486 block += 64; |
725 | 487 mb++; |
723 | 488 } |
489 } | |
2967 | 490 |
723 | 491 /* compute idct and place blocks */ |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
492 block = &sblock[0][0]; |
723 | 493 mb = mb_data; |
494 for(mb_index = 0; mb_index < 5; mb_index++) { | |
495 v = *mb_pos_ptr++; | |
496 mb_x = v & 0xff; | |
497 mb_y = v >> 8; | |
3167 | 498 if (s->sys->pix_fmt == PIX_FMT_YUV422P) { |
499 y_ptr = s->picture.data[0] + ((mb_y * s->picture.linesize[0] + (mb_x>>1))<<log2_blocksize); | |
2849 | 500 c_offset = ((mb_y * s->picture.linesize[1] + (mb_x >> 2))<<log2_blocksize); |
3167 | 501 } else { /* 4:1:1 or 4:2:0 */ |
502 y_ptr = s->picture.data[0] + ((mb_y * s->picture.linesize[0] + mb_x)<<log2_blocksize); | |
503 if (s->sys->pix_fmt == PIX_FMT_YUV411P) | |
504 c_offset = ((mb_y * s->picture.linesize[1] + (mb_x >> 2))<<log2_blocksize); | |
505 else /* 4:2:0 */ | |
506 c_offset = (((mb_y >> 1) * s->picture.linesize[1] + (mb_x >> 1))<<log2_blocksize); | |
507 } | |
723 | 508 for(j = 0;j < 6; j++) { |
2849 | 509 idct_put = s->idct_put[mb->dct_mode && log2_blocksize==3]; |
3167 | 510 if (s->sys->pix_fmt == PIX_FMT_YUV422P) { /* 4:2:2 */ |
511 if (j == 0 || j == 2) { | |
512 /* Y0 Y1 */ | |
513 idct_put(y_ptr + ((j >> 1)<<log2_blocksize), | |
1489
337d13aee605
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
1416
diff
changeset
|
514 s->picture.linesize[0], block); |
3167 | 515 } else if(j > 3) { |
516 /* Cr Cb */ | |
517 idct_put(s->picture.data[6 - j] + c_offset, | |
518 s->picture.linesize[6 - j], block); | |
723 | 519 } |
3167 | 520 /* note: j=1 and j=3 are "dummy" blocks in 4:2:2 */ |
521 } else { /* 4:1:1 or 4:2:0 */ | |
522 if (j < 4) { | |
523 if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x < (704 / 8)) { | |
524 /* NOTE: at end of line, the macroblock is handled as 420 */ | |
525 idct_put(y_ptr + (j<<log2_blocksize), s->picture.linesize[0], block); | |
526 } else { | |
527 idct_put(y_ptr + (((j & 1) + (j >> 1) * s->picture.linesize[0])<<log2_blocksize), | |
528 s->picture.linesize[0], block); | |
737 | 529 } |
530 } else { | |
3167 | 531 if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) { |
532 uint64_t aligned_pixels[64/8]; | |
533 uint8_t *pixels= (uint8_t*)aligned_pixels; | |
534 uint8_t *c_ptr, *c_ptr1, *ptr, *ptr1; | |
535 int x, y, linesize; | |
536 /* NOTE: at end of line, the macroblock is handled as 420 */ | |
537 idct_put(pixels, 8, block); | |
538 linesize = s->picture.linesize[6 - j]; | |
539 c_ptr = s->picture.data[6 - j] + c_offset; | |
540 ptr = pixels; | |
541 for(y = 0;y < (1<<log2_blocksize); y++) { | |
542 ptr1= ptr + (1<<(log2_blocksize-1)); | |
543 c_ptr1 = c_ptr + (linesize<<log2_blocksize); | |
544 for(x=0; x < (1<<(log2_blocksize-1)); x++){ | |
545 c_ptr[x]= ptr[x]; c_ptr1[x]= ptr1[x]; | |
546 } | |
547 c_ptr += linesize; | |
548 ptr += 8; | |
549 } | |
550 } else { | |
551 /* don't ask me why they inverted Cb and Cr ! */ | |
552 idct_put(s->picture.data[6 - j] + c_offset, | |
553 s->picture.linesize[6 - j], block); | |
554 } | |
737 | 555 } |
723 | 556 } |
557 block += 64; | |
725 | 558 mb++; |
723 | 559 } |
560 } | |
561 } | |
562 | |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
563 #ifdef DV_CODEC_TINY_TARGET |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
564 /* Converts run and level (where level != 0) pair into vlc, returning bit size */ |
2847 | 565 static always_inline int dv_rl2vlc(int run, int level, int sign, uint32_t* vlc) |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
566 { |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
567 int size; |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
568 if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) { |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
569 *vlc = dv_vlc_map[run][level].vlc | sign; |
2979 | 570 size = dv_vlc_map[run][level].size; |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
571 } |
2967 | 572 else { |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
573 if (level < DV_VLC_MAP_LEV_SIZE) { |
2979 | 574 *vlc = dv_vlc_map[0][level].vlc | sign; |
575 size = dv_vlc_map[0][level].size; | |
576 } else { | |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
577 *vlc = 0xfe00 | (level << 1) | sign; |
2979 | 578 size = 16; |
579 } | |
580 if (run) { | |
581 *vlc |= ((run < 16) ? dv_vlc_map[run-1][0].vlc : | |
582 (0x1f80 | (run - 1))) << size; | |
583 size += (run < 16) ? dv_vlc_map[run-1][0].size : 13; | |
584 } | |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
585 } |
2967 | 586 |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
587 return size; |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
588 } |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
589 |
2847 | 590 static always_inline int dv_rl2vlc_size(int run, int level) |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
591 { |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
592 int size; |
2967 | 593 |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
594 if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) { |
2979 | 595 size = dv_vlc_map[run][level].size; |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
596 } |
2967 | 597 else { |
2979 | 598 size = (level < DV_VLC_MAP_LEV_SIZE) ? dv_vlc_map[0][level].size : 16; |
599 if (run) { | |
600 size += (run < 16) ? dv_vlc_map[run-1][0].size : 13; | |
601 } | |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
602 } |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
603 return size; |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
604 } |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
605 #else |
2847 | 606 static always_inline int dv_rl2vlc(int run, int l, int sign, uint32_t* vlc) |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
607 { |
2847 | 608 *vlc = dv_vlc_map[run][l].vlc | sign; |
609 return dv_vlc_map[run][l].size; | |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
610 } |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
611 |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
612 static always_inline int dv_rl2vlc_size(int run, int l) |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
613 { |
2847 | 614 return dv_vlc_map[run][l].size; |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
615 } |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
616 #endif |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
617 |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
618 typedef struct EncBlockInfo { |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
619 int area_q[4]; |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
620 int bit_size[4]; |
2847 | 621 int prev[5]; |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
622 int cur_ac; |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
623 int cno; |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
624 int dct_mode; |
2847 | 625 DCTELEM mb[64]; |
626 uint8_t next[64]; | |
627 uint8_t sign[64]; | |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
628 uint8_t partial_bit_count; |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
629 uint32_t partial_bit_buffer; /* we can't use uint16_t here */ |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
630 } EncBlockInfo; |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
631 |
2967 | 632 static always_inline PutBitContext* dv_encode_ac(EncBlockInfo* bi, PutBitContext* pb_pool, |
2847 | 633 PutBitContext* pb_end) |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
634 { |
2847 | 635 int prev; |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
636 int bits_left; |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
637 PutBitContext* pb = pb_pool; |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
638 int size = bi->partial_bit_count; |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
639 uint32_t vlc = bi->partial_bit_buffer; |
2847 | 640 |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
641 bi->partial_bit_count = bi->partial_bit_buffer = 0; |
2847 | 642 for(;;){ |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
643 /* Find suitable storage space */ |
1875
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1726
diff
changeset
|
644 for (; size > (bits_left = put_bits_left(pb)); pb++) { |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
645 if (bits_left) { |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
646 size -= bits_left; |
2979 | 647 put_bits(pb, bits_left, vlc >> size); |
648 vlc = vlc & ((1<<size)-1); | |
649 } | |
650 if (pb + 1 >= pb_end) { | |
651 bi->partial_bit_count = size; | |
652 bi->partial_bit_buffer = vlc; | |
653 return pb; | |
654 } | |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
655 } |
2967 | 656 |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
657 /* Store VLC */ |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
658 put_bits(pb, size, vlc); |
2967 | 659 |
2847 | 660 if(bi->cur_ac>=64) |
661 break; | |
2967 | 662 |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
663 /* Construct the next VLC */ |
2847 | 664 prev= bi->cur_ac; |
665 bi->cur_ac = bi->next[prev]; | |
666 if(bi->cur_ac < 64){ | |
667 size = dv_rl2vlc(bi->cur_ac - prev - 1, bi->mb[bi->cur_ac], bi->sign[bi->cur_ac], &vlc); | |
668 } else { | |
669 size = 4; vlc = 6; /* End Of Block stamp */ | |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
670 } |
2847 | 671 } |
672 return pb; | |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
673 } |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
674 |
2967 | 675 static always_inline void dv_set_class_number(DCTELEM* blk, EncBlockInfo* bi, |
3149
2679184e8be0
AC coefficient weighing (per SMPTE 314M) for the DV encoder and decoder. The
romansh
parents:
3148
diff
changeset
|
676 const uint8_t* zigzag_scan, const int *weight, int bias) |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
677 { |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
678 int i, area; |
3152
28a087ad41d1
Assign class 2 to most macroblocks by default, instead of a more conservative
romansh
parents:
3150
diff
changeset
|
679 /* We offer two different methods for class number assignment: the |
28a087ad41d1
Assign class 2 to most macroblocks by default, instead of a more conservative
romansh
parents:
3150
diff
changeset
|
680 method suggested in SMPTE 314M Table 22, and an improved |
28a087ad41d1
Assign class 2 to most macroblocks by default, instead of a more conservative
romansh
parents:
3150
diff
changeset
|
681 method. The SMPTE method is very conservative; it assigns class |
28a087ad41d1
Assign class 2 to most macroblocks by default, instead of a more conservative
romansh
parents:
3150
diff
changeset
|
682 3 (i.e. severe quantization) to any block where the largest AC |
28a087ad41d1
Assign class 2 to most macroblocks by default, instead of a more conservative
romansh
parents:
3150
diff
changeset
|
683 component is greater than 36. ffmpeg's DV encoder tracks AC bit |
28a087ad41d1
Assign class 2 to most macroblocks by default, instead of a more conservative
romansh
parents:
3150
diff
changeset
|
684 consumption precisely, so there is no need to bias most blocks |
28a087ad41d1
Assign class 2 to most macroblocks by default, instead of a more conservative
romansh
parents:
3150
diff
changeset
|
685 towards strongly lossy compression. Instead, we assign class 2 |
28a087ad41d1
Assign class 2 to most macroblocks by default, instead of a more conservative
romansh
parents:
3150
diff
changeset
|
686 to most blocks, and use class 3 only when strictly necessary |
28a087ad41d1
Assign class 2 to most macroblocks by default, instead of a more conservative
romansh
parents:
3150
diff
changeset
|
687 (for blocks whose largest AC component exceeds 255). */ |
28a087ad41d1
Assign class 2 to most macroblocks by default, instead of a more conservative
romansh
parents:
3150
diff
changeset
|
688 |
28a087ad41d1
Assign class 2 to most macroblocks by default, instead of a more conservative
romansh
parents:
3150
diff
changeset
|
689 #if 0 /* SMPTE spec method */ |
2847 | 690 static const int classes[] = {12, 24, 36, 0xffff}; |
3152
28a087ad41d1
Assign class 2 to most macroblocks by default, instead of a more conservative
romansh
parents:
3150
diff
changeset
|
691 #else /* improved ffmpeg method */ |
28a087ad41d1
Assign class 2 to most macroblocks by default, instead of a more conservative
romansh
parents:
3150
diff
changeset
|
692 static const int classes[] = {-1, -1, 255, 0xffff}; |
28a087ad41d1
Assign class 2 to most macroblocks by default, instead of a more conservative
romansh
parents:
3150
diff
changeset
|
693 #endif |
28a087ad41d1
Assign class 2 to most macroblocks by default, instead of a more conservative
romansh
parents:
3150
diff
changeset
|
694 int max=classes[0]; |
2847 | 695 int prev=0; |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
696 |
2967 | 697 bi->mb[0] = blk[0]; |
698 | |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
699 for (area = 0; area < 4; area++) { |
2847 | 700 bi->prev[area] = prev; |
701 bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :) | |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
702 for (i=mb_area_start[area]; i<mb_area_start[area+1]; i++) { |
2847 | 703 int level = blk[zigzag_scan[i]]; |
2967 | 704 |
2847 | 705 if (level+15 > 30U) { |
706 bi->sign[i] = (level>>31)&1; | |
3149
2679184e8be0
AC coefficient weighing (per SMPTE 314M) for the DV encoder and decoder. The
romansh
parents:
3148
diff
changeset
|
707 /* weigh it and and shift down into range, adding for rounding */ |
2679184e8be0
AC coefficient weighing (per SMPTE 314M) for the DV encoder and decoder. The
romansh
parents:
3148
diff
changeset
|
708 /* the extra division by a factor of 2^4 reverses the 8x expansion of the DCT |
2679184e8be0
AC coefficient weighing (per SMPTE 314M) for the DV encoder and decoder. The
romansh
parents:
3148
diff
changeset
|
709 AND the 2x doubling of the weights */ |
2679184e8be0
AC coefficient weighing (per SMPTE 314M) for the DV encoder and decoder. The
romansh
parents:
3148
diff
changeset
|
710 level = (ABS(level) * weight[i] + (1<<(dv_weight_bits+3))) >> (dv_weight_bits+4); |
2679184e8be0
AC coefficient weighing (per SMPTE 314M) for the DV encoder and decoder. The
romansh
parents:
3148
diff
changeset
|
711 bi->mb[i] = level; |
2847 | 712 if(level>max) max= level; |
713 bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, level); | |
714 bi->next[prev]= i; | |
715 prev= i; | |
716 } | |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
717 } |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
718 } |
2847 | 719 bi->next[prev]= i; |
720 for(bi->cno = 0; max > classes[bi->cno]; bi->cno++); | |
721 | |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
722 bi->cno += bias; |
2967 | 723 |
2847 | 724 if (bi->cno >= 3) { |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
725 bi->cno = 3; |
2847 | 726 prev=0; |
727 i= bi->next[prev]; | |
728 for (area = 0; area < 4; area++) { | |
729 bi->prev[area] = prev; | |
730 bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :) | |
731 for (; i<mb_area_start[area+1]; i= bi->next[i]) { | |
732 bi->mb[i] >>=1; | |
2967 | 733 |
2847 | 734 if (bi->mb[i]) { |
735 bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, bi->mb[i]); | |
736 bi->next[prev]= i; | |
737 prev= i; | |
738 } | |
739 } | |
740 } | |
741 bi->next[prev]= i; | |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
742 } |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
743 } |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
744 |
2847 | 745 //FIXME replace this by dsputil |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
746 #define SC(x, y) ((s[x] - s[y]) ^ ((s[x] - s[y]) >> 7)) |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
747 static always_inline int dv_guess_dct_mode(DCTELEM *blk) { |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
748 DCTELEM *s; |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
749 int score88 = 0; |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
750 int score248 = 0; |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
751 int i; |
2967 | 752 |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
753 /* Compute 8-8 score (small values give a better chance for 8-8 DCT) */ |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
754 s = blk; |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
755 for(i=0; i<7; i++) { |
2967 | 756 score88 += SC(0, 8) + SC(1, 9) + SC(2, 10) + SC(3, 11) + |
2979 | 757 SC(4, 12) + SC(5,13) + SC(6, 14) + SC(7, 15); |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
758 s += 8; |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
759 } |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
760 /* Compute 2-4-8 score (small values give a better chance for 2-4-8 DCT) */ |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
761 s = blk; |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
762 for(i=0; i<6; i++) { |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
763 score248 += SC(0, 16) + SC(1,17) + SC(2, 18) + SC(3, 19) + |
2979 | 764 SC(4, 20) + SC(5,21) + SC(6, 22) + SC(7, 23); |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
765 s += 8; |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
766 } |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
767 |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
768 return (score88 - score248 > -10); |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
769 } |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
770 |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
771 static inline void dv_guess_qnos(EncBlockInfo* blks, int* qnos) |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
772 { |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
773 int size[5]; |
3140 | 774 int i, j, k, a, prev, a2; |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
775 EncBlockInfo* b; |
2847 | 776 |
3146
dcae1bde37ac
size[0-3] are not initialized (and can get random negative trash
michael
parents:
3143
diff
changeset
|
777 size[0] = size[1] = size[2] = size[3] = size[4] = 1<<24; |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
778 do { |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
779 b = blks; |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
780 for (i=0; i<5; i++) { |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
781 if (!qnos[i]) |
2979 | 782 continue; |
2967 | 783 |
2979 | 784 qnos[i]--; |
785 size[i] = 0; | |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
786 for (j=0; j<6; j++, b++) { |
2979 | 787 for (a=0; a<4; a++) { |
788 if (b->area_q[a] != dv_quant_shifts[qnos[i] + dv_quant_offset[b->cno]][a]) { | |
789 b->bit_size[a] = 1; // 4 areas 4 bits for EOB :) | |
790 b->area_q[a]++; | |
2847 | 791 prev= b->prev[a]; |
3147 | 792 assert(b->next[prev] >= mb_area_start[a+1] || b->mb[prev]); |
2847 | 793 for (k= b->next[prev] ; k<mb_area_start[a+1]; k= b->next[k]) { |
2979 | 794 b->mb[k] >>= 1; |
795 if (b->mb[k]) { | |
2847 | 796 b->bit_size[a] += dv_rl2vlc_size(k - prev - 1, b->mb[k]); |
2979 | 797 prev= k; |
2847 | 798 } else { |
3140 | 799 if(b->next[k] >= mb_area_start[a+1] && b->next[k]<64){ |
3146
dcae1bde37ac
size[0-3] are not initialized (and can get random negative trash
michael
parents:
3143
diff
changeset
|
800 for(a2=a+1; b->next[k] >= mb_area_start[a2+1]; a2++) |
dcae1bde37ac
size[0-3] are not initialized (and can get random negative trash
michael
parents:
3143
diff
changeset
|
801 b->prev[a2] = prev; |
3140 | 802 assert(a2<4); |
803 assert(b->mb[b->next[k]]); | |
804 b->bit_size[a2] += dv_rl2vlc_size(b->next[k] - prev - 1, b->mb[b->next[k]]) | |
805 -dv_rl2vlc_size(b->next[k] - k - 1, b->mb[b->next[k]]); | |
3147 | 806 assert(b->prev[a2]==k && (a2+1 >= 4 || b->prev[a2+1]!=k)); |
807 b->prev[a2] = prev; | |
3140 | 808 } |
2847 | 809 b->next[prev] = b->next[k]; |
810 } | |
2979 | 811 } |
2847 | 812 b->prev[a+1]= prev; |
2979 | 813 } |
814 size[i] += b->bit_size[a]; | |
815 } | |
816 } | |
3142 | 817 if(vs_total_ac_bits >= size[0] + size[1] + size[2] + size[3] + size[4]) |
818 return; | |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
819 } |
3140 | 820 } while (qnos[0]|qnos[1]|qnos[2]|qnos[3]|qnos[4]); |
821 | |
822 | |
823 for(a=2; a==2 || vs_total_ac_bits < size[0]; a+=a){ | |
824 b = blks; | |
3143 | 825 size[0] = 5*6*4; //EOB |
3140 | 826 for (j=0; j<6*5; j++, b++) { |
827 prev= b->prev[0]; | |
828 for (k= b->next[prev]; k<64; k= b->next[k]) { | |
829 if(b->mb[k] < a && b->mb[k] > -a){ | |
830 b->next[prev] = b->next[k]; | |
831 }else{ | |
832 size[0] += dv_rl2vlc_size(k - prev - 1, b->mb[k]); | |
833 prev= k; | |
834 } | |
835 } | |
836 } | |
837 } | |
1567 | 838 } |
839 | |
2967 | 840 static inline void dv_encode_video_segment(DVVideoContext *s, |
841 uint8_t *dif, | |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
842 const uint16_t *mb_pos_ptr) |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
843 { |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
844 int mb_index, i, j, v; |
2967 | 845 int mb_x, mb_y, c_offset, linesize; |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
846 uint8_t* y_ptr; |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
847 uint8_t* data; |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
848 uint8_t* ptr; |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
849 int do_edge_wrap; |
3089 | 850 DECLARE_ALIGNED_8(DCTELEM, block[64]); |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
851 EncBlockInfo enc_blks[5*6]; |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
852 PutBitContext pbs[5*6]; |
2967 | 853 PutBitContext* pb; |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
854 EncBlockInfo* enc_blk; |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
855 int vs_bit_size = 0; |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
856 int qnos[5]; |
2967 | 857 |
2847 | 858 assert((((int)block) & 7) == 0); |
2967 | 859 |
1567 | 860 enc_blk = &enc_blks[0]; |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
861 pb = &pbs[0]; |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
862 for(mb_index = 0; mb_index < 5; mb_index++) { |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
863 v = *mb_pos_ptr++; |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
864 mb_x = v & 0xff; |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
865 mb_y = v >> 8; |
3167 | 866 if (s->sys->pix_fmt == PIX_FMT_YUV422P) { |
867 y_ptr = s->picture.data[0] + (mb_y * s->picture.linesize[0] * 8) + (mb_x * 4); | |
868 } else { /* 4:1:1 */ | |
869 y_ptr = s->picture.data[0] + (mb_y * s->picture.linesize[0] * 8) + (mb_x * 8); | |
870 } | |
871 if (s->sys->pix_fmt == PIX_FMT_YUV420P) { | |
872 c_offset = (((mb_y >> 1) * s->picture.linesize[1] * 8) + ((mb_x >> 1) * 8)); | |
873 } else { /* 4:2:2 or 4:1:1 */ | |
874 c_offset = ((mb_y * s->picture.linesize[1] * 8) + ((mb_x >> 2) * 8)); | |
875 } | |
2979 | 876 do_edge_wrap = 0; |
877 qnos[mb_index] = 15; /* No quantization */ | |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
878 ptr = dif + mb_index*80 + 4; |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
879 for(j = 0;j < 6; j++) { |
3167 | 880 int dummy = 0; |
881 if (s->sys->pix_fmt == PIX_FMT_YUV422P) { /* 4:2:2 */ | |
882 if (j == 0 || j == 2) { | |
883 /* Y0 Y1 */ | |
884 data = y_ptr + ((j>>1) * 8); | |
885 linesize = s->picture.linesize[0]; | |
886 } else if (j > 3) { | |
887 /* Cr Cb */ | |
888 data = s->picture.data[6 - j] + c_offset; | |
889 linesize = s->picture.linesize[6 - j]; | |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
890 } else { |
3167 | 891 /* j=1 and j=3 are "dummy" blocks, used for AC data only */ |
892 data = 0; | |
893 linesize = 0; | |
894 dummy = 1; | |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
895 } |
3167 | 896 } else { /* 4:1:1 or 4:2:0 */ |
897 if (j < 4) { /* Four Y blocks */ | |
898 /* NOTE: at end of line, the macroblock is handled as 420 */ | |
899 if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x < (704 / 8)) { | |
900 data = y_ptr + (j * 8); | |
901 } else { | |
902 data = y_ptr + ((j & 1) * 8) + ((j >> 1) * 8 * s->picture.linesize[0]); | |
903 } | |
904 linesize = s->picture.linesize[0]; | |
905 } else { /* Cr and Cb blocks */ | |
906 /* don't ask Fabrice why they inverted Cb and Cr ! */ | |
907 data = s->picture.data[6 - j] + c_offset; | |
908 linesize = s->picture.linesize[6 - j]; | |
909 if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) | |
910 do_edge_wrap = 1; | |
911 } | |
2979 | 912 } |
2967 | 913 |
2979 | 914 /* Everything is set up -- now just copy data -> DCT block */ |
915 if (do_edge_wrap) { /* Edge wrap copy: 4x16 -> 8x8 */ | |
916 uint8_t* d; | |
917 DCTELEM *b = block; | |
918 for (i=0;i<8;i++) { | |
919 d = data + 8 * linesize; | |
920 b[0] = data[0]; b[1] = data[1]; b[2] = data[2]; b[3] = data[3]; | |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
921 b[4] = d[0]; b[5] = d[1]; b[6] = d[2]; b[7] = d[3]; |
2979 | 922 data += linesize; |
923 b += 8; | |
924 } | |
925 } else { /* Simple copy: 8x8 -> 8x8 */ | |
3167 | 926 if (!dummy) |
927 s->get_pixels(block, data, linesize); | |
2979 | 928 } |
2967 | 929 |
2847 | 930 if(s->avctx->flags & CODEC_FLAG_INTERLACED_DCT) |
931 enc_blk->dct_mode = dv_guess_dct_mode(block); | |
932 else | |
933 enc_blk->dct_mode = 0; | |
2979 | 934 enc_blk->area_q[0] = enc_blk->area_q[1] = enc_blk->area_q[2] = enc_blk->area_q[3] = 0; |
935 enc_blk->partial_bit_count = 0; | |
936 enc_blk->partial_bit_buffer = 0; | |
937 enc_blk->cur_ac = 0; | |
2967 | 938 |
3167 | 939 if (dummy) { |
940 /* We rely on the fact that encoding all zeros leads to an immediate EOB, | |
941 which is precisely what the spec calls for in the "dummy" blocks. */ | |
942 memset(block, 0, sizeof(block)); | |
943 } else { | |
944 s->fdct[enc_blk->dct_mode](block); | |
945 } | |
2967 | 946 |
2979 | 947 dv_set_class_number(block, enc_blk, |
3149
2679184e8be0
AC coefficient weighing (per SMPTE 314M) for the DV encoder and decoder. The
romansh
parents:
3148
diff
changeset
|
948 enc_blk->dct_mode ? ff_zigzag248_direct : ff_zigzag_direct, |
2679184e8be0
AC coefficient weighing (per SMPTE 314M) for the DV encoder and decoder. The
romansh
parents:
3148
diff
changeset
|
949 enc_blk->dct_mode ? dv_weight_248 : dv_weight_88, |
2679184e8be0
AC coefficient weighing (per SMPTE 314M) for the DV encoder and decoder. The
romansh
parents:
3148
diff
changeset
|
950 j/4); |
2967 | 951 |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
952 init_put_bits(pb, ptr, block_sizes[j]/8); |
2979 | 953 put_bits(pb, 9, (uint16_t)(((enc_blk->mb[0] >> 3) - 1024 + 2) >> 2)); |
954 put_bits(pb, 1, enc_blk->dct_mode); | |
955 put_bits(pb, 2, enc_blk->cno); | |
2967 | 956 |
2979 | 957 vs_bit_size += enc_blk->bit_size[0] + enc_blk->bit_size[1] + |
958 enc_blk->bit_size[2] + enc_blk->bit_size[3]; | |
959 ++enc_blk; | |
960 ++pb; | |
961 ptr += block_sizes[j]/8; | |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
962 } |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
963 } |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
964 |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
965 if (vs_total_ac_bits < vs_bit_size) |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
966 dv_guess_qnos(&enc_blks[0], &qnos[0]); |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
967 |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
968 for (i=0; i<5; i++) { |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
969 dif[i*80 + 3] = qnos[i]; |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
970 } |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
971 |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
972 /* First pass over individual cells only */ |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
973 for (j=0; j<5*6; j++) |
2847 | 974 dv_encode_ac(&enc_blks[j], &pbs[j], &pbs[j+1]); |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
975 |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
976 /* Second pass over each MB space */ |
2847 | 977 for (j=0; j<5*6; j+=6) { |
978 pb= &pbs[j]; | |
979 for (i=0; i<6; i++) { | |
980 if (enc_blks[i+j].partial_bit_count) | |
981 pb=dv_encode_ac(&enc_blks[i+j], pb, &pbs[j+6]); | |
982 } | |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
983 } |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
984 |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
985 /* Third and final pass over the whole vides segment space */ |
2847 | 986 pb= &pbs[0]; |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
987 for (j=0; j<5*6; j++) { |
2847 | 988 if (enc_blks[j].partial_bit_count) |
989 pb=dv_encode_ac(&enc_blks[j], pb, &pbs[6*5]); | |
3139
e58fb7ffbb4f
print a big warning if we mess up and run out of space ...
michael
parents:
3089
diff
changeset
|
990 if (enc_blks[j].partial_bit_count) |
e58fb7ffbb4f
print a big warning if we mess up and run out of space ...
michael
parents:
3089
diff
changeset
|
991 av_log(NULL, AV_LOG_ERROR, "ac bitstream overflow\n"); |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
992 } |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
993 |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
994 for (j=0; j<5*6; j++) |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
995 flush_put_bits(&pbs[j]); |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
996 } |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
997 |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
998 static int dv_decode_mt(AVCodecContext *avctx, void* sl) |
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
999 { |
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
1000 DVVideoContext *s = avctx->priv_data; |
1904 | 1001 int slice = (size_t)sl; |
3167 | 1002 |
1003 /* which DIF channel is this? */ | |
1004 int chan = slice / (s->sys->difseg_size * 27); | |
1005 | |
1006 /* slice within the DIF channel */ | |
1007 int chan_slice = slice % (s->sys->difseg_size * 27); | |
1008 | |
1009 /* byte offset of this channel's data */ | |
1010 int chan_offset = chan * s->sys->difseg_size * 150 * 80; | |
1011 | |
1012 dv_decode_video_segment(s, &s->buf[((chan_slice/27)*6+(chan_slice/3)+chan_slice*5+7)*80 + chan_offset], | |
2979 | 1013 &s->sys->video_place[slice*5]); |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
1014 return 0; |
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
1015 } |
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
1016 |
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
1017 static int dv_encode_mt(AVCodecContext *avctx, void* sl) |
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
1018 { |
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
1019 DVVideoContext *s = avctx->priv_data; |
1904 | 1020 int slice = (size_t)sl; |
3167 | 1021 |
1022 /* which DIF channel is this? */ | |
1023 int chan = slice / (s->sys->difseg_size * 27); | |
1024 | |
1025 /* slice within the DIF channel */ | |
1026 int chan_slice = slice % (s->sys->difseg_size * 27); | |
1027 | |
1028 /* byte offset of this channel's data */ | |
1029 int chan_offset = chan * s->sys->difseg_size * 150 * 80; | |
1030 | |
1031 dv_encode_video_segment(s, &s->buf[((chan_slice/27)*6+(chan_slice/3)+chan_slice*5+7)*80 + chan_offset], | |
2979 | 1032 &s->sys->video_place[slice*5]); |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
1033 return 0; |
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
1034 } |
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
1035 |
723 | 1036 /* NOTE: exactly one frame must be given (120000 bytes for NTSC, |
3167 | 1037 144000 bytes for PAL - or twice those for 50Mbps) */ |
2967 | 1038 static int dvvideo_decode_frame(AVCodecContext *avctx, |
723 | 1039 void *data, int *data_size, |
1064 | 1040 uint8_t *buf, int buf_size) |
723 | 1041 { |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
1042 DVVideoContext *s = avctx->priv_data; |
2967 | 1043 |
1489
337d13aee605
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
1416
diff
changeset
|
1044 s->sys = dv_frame_profile(buf); |
337d13aee605
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
1416
diff
changeset
|
1045 if (!s->sys || buf_size < s->sys->frame_size) |
337d13aee605
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
1416
diff
changeset
|
1046 return -1; /* NOTE: we only accept several full frames */ |
723 | 1047 |
1228 | 1048 if(s->picture.data[0]) |
1049 avctx->release_buffer(avctx, &s->picture); | |
2967 | 1050 |
1489
337d13aee605
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
1416
diff
changeset
|
1051 s->picture.reference = 0; |
2822
fdedaa2e6da4
DV video encoder/decoder doesn't set keyframe and picture type properties patch by (Edward Hervey:bilboed,gmail com)
michael
parents:
2661
diff
changeset
|
1052 s->picture.key_frame = 1; |
fdedaa2e6da4
DV video encoder/decoder doesn't set keyframe and picture type properties patch by (Edward Hervey:bilboed,gmail com)
michael
parents:
2661
diff
changeset
|
1053 s->picture.pict_type = FF_I_TYPE; |
1489
337d13aee605
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
1416
diff
changeset
|
1054 avctx->pix_fmt = s->sys->pix_fmt; |
2849 | 1055 avcodec_set_dimensions(avctx, s->sys->width, s->sys->height); |
903 | 1056 if(avctx->get_buffer(avctx, &s->picture) < 0) { |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1567
diff
changeset
|
1057 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n"); |
903 | 1058 return -1; |
835 | 1059 } |
1543
7542cb99b950
* providing MPEG codecs with a generic fields in AVFrame to use.
romansh
parents:
1540
diff
changeset
|
1060 s->picture.interlaced_frame = 1; |
1547 | 1061 s->picture.top_field_first = 0; |
835 | 1062 |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
1063 s->buf = buf; |
3016
97e6c0f82182
Moving dv_anchor back to the global scope. This creates a tiny memory
romansh
parents:
2991
diff
changeset
|
1064 avctx->execute(avctx, dv_decode_mt, (void**)&dv_anchor[0], NULL, |
3167 | 1065 s->sys->n_difchan * s->sys->difseg_size * 27); |
2967 | 1066 |
734
2d6b3e3d6c6f
10l - MMX/FPU state was not restored, causing nonsense fpu behaviour in caller (mplayer)
arpi_esp
parents:
733
diff
changeset
|
1067 emms_c(); |
2d6b3e3d6c6f
10l - MMX/FPU state was not restored, causing nonsense fpu behaviour in caller (mplayer)
arpi_esp
parents:
733
diff
changeset
|
1068 |
723 | 1069 /* return image */ |
925 | 1070 *data_size = sizeof(AVFrame); |
1071 *(AVFrame*)data= s->picture; | |
2967 | 1072 |
1489
337d13aee605
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
1416
diff
changeset
|
1073 return s->sys->frame_size; |
723 | 1074 } |
1075 | |
2967 | 1076 static int dvvideo_encode_frame(AVCodecContext *c, uint8_t *buf, int buf_size, |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
1077 void *data) |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
1078 { |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
1079 DVVideoContext *s = c->priv_data; |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
1080 |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
1081 s->sys = dv_codec_profile(c); |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
1082 if (!s->sys) |
2979 | 1083 return -1; |
2422 | 1084 if(buf_size < s->sys->frame_size) |
1085 return -1; | |
1086 | |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
1087 c->pix_fmt = s->sys->pix_fmt; |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
1088 s->picture = *((AVFrame *)data); |
2822
fdedaa2e6da4
DV video encoder/decoder doesn't set keyframe and picture type properties patch by (Edward Hervey:bilboed,gmail com)
michael
parents:
2661
diff
changeset
|
1089 s->picture.key_frame = 1; |
fdedaa2e6da4
DV video encoder/decoder doesn't set keyframe and picture type properties patch by (Edward Hervey:bilboed,gmail com)
michael
parents:
2661
diff
changeset
|
1090 s->picture.pict_type = FF_I_TYPE; |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
1091 |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
1092 s->buf = buf; |
3016
97e6c0f82182
Moving dv_anchor back to the global scope. This creates a tiny memory
romansh
parents:
2991
diff
changeset
|
1093 c->execute(c, dv_encode_mt, (void**)&dv_anchor[0], NULL, |
3167 | 1094 s->sys->n_difchan * s->sys->difseg_size * 27); |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
1095 |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
1096 emms_c(); |
3167 | 1097 |
1098 /* Fill in just enough of the header for dv_frame_profile() to | |
1099 return the correct result, so that the frame can be decoded | |
1100 correctly. The rest of the metadata is filled in by the dvvideo | |
1101 avformat. (this should probably change so that encode_frame() | |
1102 fills in ALL of the metadata - e.g. for Quicktime-wrapped DV | |
1103 streams) */ | |
1104 | |
1105 /* NTSC/PAL format */ | |
1106 buf[3] = s->sys->dsf ? 0x80 : 0x00; | |
1107 | |
1108 /* 25Mbps or 50Mbps */ | |
1109 buf[80*5 + 48 + 3] = (s->sys->pix_fmt == PIX_FMT_YUV422P) ? 0x4 : 0x0; | |
1110 | |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
1111 return s->sys->frame_size; |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
1112 } |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
1113 |
2991
d377b0788381
Fix DV memory leak and allow multiple instances patch by (Burkhard Plaum?)
michael
parents:
2979
diff
changeset
|
1114 static int dvvideo_close(AVCodecContext *c) |
d377b0788381
Fix DV memory leak and allow multiple instances patch by (Burkhard Plaum?)
michael
parents:
2979
diff
changeset
|
1115 { |
d377b0788381
Fix DV memory leak and allow multiple instances patch by (Burkhard Plaum?)
michael
parents:
2979
diff
changeset
|
1116 |
d377b0788381
Fix DV memory leak and allow multiple instances patch by (Burkhard Plaum?)
michael
parents:
2979
diff
changeset
|
1117 return 0; |
d377b0788381
Fix DV memory leak and allow multiple instances patch by (Burkhard Plaum?)
michael
parents:
2979
diff
changeset
|
1118 } |
d377b0788381
Fix DV memory leak and allow multiple instances patch by (Burkhard Plaum?)
michael
parents:
2979
diff
changeset
|
1119 |
d377b0788381
Fix DV memory leak and allow multiple instances patch by (Burkhard Plaum?)
michael
parents:
2979
diff
changeset
|
1120 |
2661
b2846918585c
a few #ifdef CONFIG_X_ENCODER, patch by (Roine Gustafsson <roine users.sourceforge net]
michael
parents:
2614
diff
changeset
|
1121 #ifdef CONFIG_DVVIDEO_ENCODER |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
1122 AVCodec dvvideo_encoder = { |
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
1123 "dvvideo", |
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
1124 CODEC_TYPE_VIDEO, |
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
1125 CODEC_ID_DVVIDEO, |
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
1126 sizeof(DVVideoContext), |
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
1127 dvvideo_init, |
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
1128 dvvideo_encode_frame, |
2991
d377b0788381
Fix DV memory leak and allow multiple instances patch by (Burkhard Plaum?)
michael
parents:
2979
diff
changeset
|
1129 dvvideo_close, |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
1130 NULL, |
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
1131 CODEC_CAP_DR1, |
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
1132 NULL |
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
1133 }; |
2661
b2846918585c
a few #ifdef CONFIG_X_ENCODER, patch by (Roine Gustafsson <roine users.sourceforge net]
michael
parents:
2614
diff
changeset
|
1134 #endif // CONFIG_DVVIDEO_ENCODER |
723 | 1135 |
1136 AVCodec dvvideo_decoder = { | |
1137 "dvvideo", | |
1138 CODEC_TYPE_VIDEO, | |
1139 CODEC_ID_DVVIDEO, | |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
1140 sizeof(DVVideoContext), |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
1141 dvvideo_init, |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
1142 NULL, |
2991
d377b0788381
Fix DV memory leak and allow multiple instances patch by (Burkhard Plaum?)
michael
parents:
2979
diff
changeset
|
1143 dvvideo_close, |
723 | 1144 dvvideo_decode_frame, |
835 | 1145 CODEC_CAP_DR1, |
723 | 1146 NULL |
1147 }; |