Mercurial > libavcodec.hg
annotate dv.c @ 5311:7742d5411c9d libavcodec
AC-3 decoder, soc revision 48, Aug 16 11:27:49 2006 UTC by cloud9
I realized that the bug was not in the imdct routine but in the
get_transform_coeffs.
Fixed it.
Code now uses the ffmpeg's imdct routines.
All the mplayer's ac3 samples are decoded
successfully.
Also improved downmixing.
Now all the downmixing coeffcients for channels
are normalized such that the sum of coefficients
used to construct the output for single channel
never exceeds 1.0.
author | jbr |
---|---|
date | Sat, 14 Jul 2007 15:58:42 +0000 |
parents | c23a5c8263bc |
children | f4859c13426b |
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 * |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3806
diff
changeset
|
15 * This file is part of FFmpeg. |
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3806
diff
changeset
|
16 * |
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3806
diff
changeset
|
17 * FFmpeg is free software; you can redistribute it and/or |
723 | 18 * modify it under the terms of the GNU Lesser General Public |
19 * License as published by the Free Software Foundation; either | |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3806
diff
changeset
|
20 * version 2.1 of the License, or (at your option) any later version. |
723 | 21 * |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3806
diff
changeset
|
22 * FFmpeg is distributed in the hope that it will be useful, |
723 | 23 * but WITHOUT ANY WARRANTY; without even the implied warranty of |
24 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
25 * Lesser General Public License for more details. | |
26 * | |
27 * You should have received a copy of the GNU Lesser General Public | |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3806
diff
changeset
|
28 * License along with FFmpeg; if not, write to the Free Software |
3036
0b546eab515d
Update licensing information: The FSF changed postal address.
diego
parents:
3016
diff
changeset
|
29 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
723 | 30 */ |
1106 | 31 |
32 /** | |
33 * @file dv.c | |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
34 * DV codec. |
1106 | 35 */ |
3649 | 36 #define ALT_BITSTREAM_READER |
723 | 37 #include "avcodec.h" |
38 #include "dsputil.h" | |
39 #include "mpegvideo.h" | |
40 #include "simple_idct.h" | |
1489
337d13aee605
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
1416
diff
changeset
|
41 #include "dvdata.h" |
723 | 42 |
2847 | 43 //#undef NDEBUG |
44 //#include <assert.h> | |
45 | |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
46 typedef struct DVVideoContext { |
1489
337d13aee605
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
1416
diff
changeset
|
47 const DVprofile* sys; |
925 | 48 AVFrame picture; |
2847 | 49 AVCodecContext *avctx; |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
50 uint8_t *buf; |
2967 | 51 |
1064 | 52 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
|
53 uint8_t dv_idct_shift[2][2][22][64]; |
2967 | 54 |
1489
337d13aee605
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
1416
diff
changeset
|
55 void (*get_pixels)(DCTELEM *block, const uint8_t *pixels, int line_size); |
1567 | 56 void (*fdct[2])(DCTELEM *block); |
57 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
|
58 } DVVideoContext; |
2991
d377b0788381
Fix DV memory leak and allow multiple instances patch by (Burkhard Plaum?)
michael
parents:
2979
diff
changeset
|
59 |
3167 | 60 /* MultiThreading - dv_anchor applies to entire DV codec, not just the avcontext */ |
61 /* one element is needed for each video segment in a DV frame */ | |
62 /* at most there are 2 DIF channels * 12 DIF sequences * 27 video segments (PAL 50Mbps) */ | |
63 #define DV_ANCHOR_SIZE (2*12*27) | |
64 | |
65 static void* dv_anchor[DV_ANCHOR_SIZE]; | |
723 | 66 |
1489
337d13aee605
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
1416
diff
changeset
|
67 #define TEX_VLC_BITS 9 |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
68 |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
69 #ifdef DV_CODEC_TINY_TARGET |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
70 #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
|
71 #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
|
72 #else |
2967 | 73 #define DV_VLC_MAP_RUN_SIZE 64 |
2847 | 74 #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
|
75 #endif |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
76 |
723 | 77 /* XXX: also include quantization */ |
4661 | 78 static RL_VLC_ELEM dv_rl_vlc[1184]; |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
79 /* VLC encoding lookup table */ |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
80 static struct dv_vlc_pair { |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
81 uint32_t vlc; |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
82 uint8_t size; |
4666 | 83 } dv_vlc_map[DV_VLC_MAP_RUN_SIZE][DV_VLC_MAP_LEV_SIZE]; |
723 | 84 |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
85 static void dv_build_unquantize_tables(DVVideoContext *s, uint8_t* perm) |
723 | 86 { |
725 | 87 int i, q, j; |
723 | 88 |
89 /* NOTE: max left shift is 6 */ | |
725 | 90 for(q = 0; q < 22; q++) { |
1567 | 91 /* 88DCT */ |
725 | 92 for(i = 1; i < 64; i++) { |
93 /* 88 table */ | |
1567 | 94 j = perm[i]; |
1905
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
95 s->dv_idct_shift[0][0][q][j] = |
725 | 96 dv_quant_shifts[q][dv_88_areas[i]] + 1; |
2979 | 97 s->dv_idct_shift[1][0][q][j] = s->dv_idct_shift[0][0][q][j] + 1; |
725 | 98 } |
2967 | 99 |
1567 | 100 /* 248DCT */ |
725 | 101 for(i = 1; i < 64; i++) { |
102 /* 248 table */ | |
2967 | 103 s->dv_idct_shift[0][1][q][i] = |
1567 | 104 dv_quant_shifts[q][dv_248_areas[i]] + 1; |
2979 | 105 s->dv_idct_shift[1][1][q][i] = s->dv_idct_shift[0][1][q][i] + 1; |
723 | 106 } |
107 } | |
108 } | |
109 | |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
110 static int dvvideo_init(AVCodecContext *avctx) |
723 | 111 { |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
112 DVVideoContext *s = avctx->priv_data; |
1567 | 113 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
|
114 static int done=0; |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
115 int i, j; |
723 | 116 |
117 if (!done) { | |
1489
337d13aee605
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
1416
diff
changeset
|
118 VLC dv_vlc; |
1905
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
119 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
|
120 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
|
121 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
|
122 int16_t new_dv_vlc_level[NB_DV_VLC*2]; |
723 | 123 |
124 done = 1; | |
125 | |
2979 | 126 /* dv_anchor lets each thread know its Id */ |
3167 | 127 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
|
128 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
|
129 |
2979 | 130 /* it's faster to include sign bit in a generic VLC parsing scheme */ |
131 for (i=0, j=0; i<NB_DV_VLC; i++, j++) { | |
132 new_dv_vlc_bits[j] = dv_vlc_bits[i]; | |
133 new_dv_vlc_len[j] = dv_vlc_len[i]; | |
134 new_dv_vlc_run[j] = dv_vlc_run[i]; | |
135 new_dv_vlc_level[j] = dv_vlc_level[i]; | |
2967 | 136 |
2979 | 137 if (dv_vlc_level[i]) { |
138 new_dv_vlc_bits[j] <<= 1; | |
139 new_dv_vlc_len[j]++; | |
1905
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
140 |
2979 | 141 j++; |
142 new_dv_vlc_bits[j] = (dv_vlc_bits[i] << 1) | 1; | |
143 new_dv_vlc_len[j] = dv_vlc_len[i] + 1; | |
144 new_dv_vlc_run[j] = dv_vlc_run[i]; | |
145 new_dv_vlc_level[j] = -dv_vlc_level[i]; | |
146 } | |
147 } | |
2967 | 148 |
723 | 149 /* NOTE: as a trick, we use the fact the no codes are unused |
150 to accelerate the parsing of partial codes */ | |
2967 | 151 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
|
152 new_dv_vlc_len, 1, 1, new_dv_vlc_bits, 2, 2, 0); |
4661 | 153 assert(dv_vlc.table_size == 1184); |
3016
97e6c0f82182
Moving dv_anchor back to the global scope. This creates a tiny memory
romansh
parents:
2991
diff
changeset
|
154 |
723 | 155 for(i = 0; i < dv_vlc.table_size; i++){ |
156 int code= dv_vlc.table[i][0]; | |
157 int len = dv_vlc.table[i][1]; | |
158 int level, run; | |
2967 | 159 |
723 | 160 if(len<0){ //more bits needed |
161 run= 0; | |
162 level= code; | |
163 } else { | |
1905
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
164 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
|
165 level= new_dv_vlc_level[code]; |
723 | 166 } |
1886
fbcf02596520
* DV decoder simplifications. Now it looks to be 6% faster. At least
romansh
parents:
1875
diff
changeset
|
167 dv_rl_vlc[i].len = len; |
fbcf02596520
* DV decoder simplifications. Now it looks to be 6% faster. At least
romansh
parents:
1875
diff
changeset
|
168 dv_rl_vlc[i].level = level; |
fbcf02596520
* DV decoder simplifications. Now it looks to be 6% faster. At least
romansh
parents:
1875
diff
changeset
|
169 dv_rl_vlc[i].run = run; |
723 | 170 } |
2979 | 171 free_vlc(&dv_vlc); |
1489
337d13aee605
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
1416
diff
changeset
|
172 |
2979 | 173 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
|
174 if (dv_vlc_run[i] >= DV_VLC_MAP_RUN_SIZE) |
2979 | 175 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
|
176 #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
|
177 if (dv_vlc_level[i] >= DV_VLC_MAP_LEV_SIZE) |
2979 | 178 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
|
179 #endif |
2967 | 180 |
2979 | 181 if (dv_vlc_map[dv_vlc_run[i]][dv_vlc_level[i]].size != 0) |
182 continue; | |
2967 | 183 |
2979 | 184 dv_vlc_map[dv_vlc_run[i]][dv_vlc_level[i]].vlc = dv_vlc_bits[i] << |
185 (!!dv_vlc_level[i]); | |
186 dv_vlc_map[dv_vlc_run[i]][dv_vlc_level[i]].size = dv_vlc_len[i] + | |
187 (!!dv_vlc_level[i]); | |
188 } | |
189 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
|
190 #ifdef DV_CODEC_TINY_TARGET |
2979 | 191 for (j = 1; j < DV_VLC_MAP_LEV_SIZE; j++) { |
192 if (dv_vlc_map[i][j].size == 0) { | |
193 dv_vlc_map[i][j].vlc = dv_vlc_map[0][j].vlc | | |
194 (dv_vlc_map[i-1][0].vlc << (dv_vlc_map[0][j].size)); | |
195 dv_vlc_map[i][j].size = dv_vlc_map[i-1][0].size + | |
196 dv_vlc_map[0][j].size; | |
197 } | |
198 } | |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
199 #else |
2979 | 200 for (j = 1; j < DV_VLC_MAP_LEV_SIZE/2; j++) { |
201 if (dv_vlc_map[i][j].size == 0) { | |
202 dv_vlc_map[i][j].vlc = dv_vlc_map[0][j].vlc | | |
203 (dv_vlc_map[i-1][0].vlc << (dv_vlc_map[0][j].size)); | |
204 dv_vlc_map[i][j].size = dv_vlc_map[i-1][0].size + | |
205 dv_vlc_map[0][j].size; | |
206 } | |
207 dv_vlc_map[i][((uint16_t)(-j))&0x1ff].vlc = | |
208 dv_vlc_map[i][j].vlc | 1; | |
209 dv_vlc_map[i][((uint16_t)(-j))&0x1ff].size = | |
210 dv_vlc_map[i][j].size; | |
211 } | |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
212 #endif |
2979 | 213 } |
723 | 214 } |
725 | 215 |
1567 | 216 /* Generic DSP setup */ |
217 dsputil_init(&dsp, avctx); | |
218 s->get_pixels = dsp.get_pixels; | |
725 | 219 |
1567 | 220 /* 88DCT setup */ |
221 s->fdct[0] = dsp.fdct; | |
222 s->idct_put[0] = dsp.idct_put; | |
223 for (i=0; i<64; i++) | |
224 s->dv_zigzag[0][i] = dsp.idct_permutation[ff_zigzag_direct[i]]; | |
725 | 225 |
1567 | 226 /* 248DCT setup */ |
227 s->fdct[1] = dsp.fdct248; | |
228 s->idct_put[1] = simple_idct248_put; // FIXME: need to add it to DSP | |
2849 | 229 if(avctx->lowres){ |
230 for (i=0; i<64; i++){ | |
231 int j= ff_zigzag248_direct[i]; | |
232 s->dv_zigzag[1][i] = dsp.idct_permutation[(j&7) + (j&8)*4 + (j&48)/2]; | |
233 } | |
234 }else | |
235 memcpy(s->dv_zigzag[1], ff_zigzag248_direct, 64); | |
725 | 236 |
723 | 237 /* XXX: do it only for constant case */ |
1567 | 238 dv_build_unquantize_tables(s, dsp.idct_permutation); |
1489
337d13aee605
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
1416
diff
changeset
|
239 |
1543
7542cb99b950
* providing MPEG codecs with a generic fields in AVFrame to use.
romansh
parents:
1540
diff
changeset
|
240 avctx->coded_frame = &s->picture; |
2847 | 241 s->avctx= avctx; |
2967 | 242 |
723 | 243 return 0; |
244 } | |
245 | |
1489
337d13aee605
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
1416
diff
changeset
|
246 // #define VLC_DEBUG |
1905
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
247 // #define printf(...) av_log(NULL, AV_LOG_ERROR, __VA_ARGS__) |
723 | 248 |
725 | 249 typedef struct BlockInfo { |
1064 | 250 const uint8_t *shift_table; |
251 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
|
252 const int *iweight_table; |
1064 | 253 uint8_t pos; /* position in block */ |
254 uint8_t dct_mode; | |
255 uint8_t partial_bit_count; | |
256 uint16_t partial_bit_buffer; | |
725 | 257 int shift_offset; |
258 } BlockInfo; | |
723 | 259 |
260 /* block size in bits */ | |
1064 | 261 static const uint16_t block_sizes[6] = { |
723 | 262 112, 112, 112, 112, 80, 80 |
263 }; | |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
264 /* 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
|
265 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
|
266 /* see dv_88_areas and dv_248_areas for details */ |
2967 | 267 static const int mb_area_start[5] = { 1, 6, 21, 43, 64 }; |
723 | 268 |
1895
e5687117cc7f
* removing casualties of battle of the wits and English language
romansh
parents:
1887
diff
changeset
|
269 static inline int get_bits_left(GetBitContext *s) |
e5687117cc7f
* removing casualties of battle of the wits and English language
romansh
parents:
1887
diff
changeset
|
270 { |
e5687117cc7f
* removing casualties of battle of the wits and English language
romansh
parents:
1887
diff
changeset
|
271 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
|
272 } |
e5687117cc7f
* removing casualties of battle of the wits and English language
romansh
parents:
1887
diff
changeset
|
273 |
e5687117cc7f
* removing casualties of battle of the wits and English language
romansh
parents:
1887
diff
changeset
|
274 static inline int get_bits_size(GetBitContext *s) |
e5687117cc7f
* removing casualties of battle of the wits and English language
romansh
parents:
1887
diff
changeset
|
275 { |
e5687117cc7f
* removing casualties of battle of the wits and English language
romansh
parents:
1887
diff
changeset
|
276 return s->size_in_bits; |
e5687117cc7f
* removing casualties of battle of the wits and English language
romansh
parents:
1887
diff
changeset
|
277 } |
e5687117cc7f
* removing casualties of battle of the wits and English language
romansh
parents:
1887
diff
changeset
|
278 |
e5687117cc7f
* removing casualties of battle of the wits and English language
romansh
parents:
1887
diff
changeset
|
279 static inline int put_bits_left(PutBitContext* s) |
e5687117cc7f
* removing casualties of battle of the wits and English language
romansh
parents:
1887
diff
changeset
|
280 { |
e5687117cc7f
* removing casualties of battle of the wits and English language
romansh
parents:
1887
diff
changeset
|
281 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
|
282 } |
e5687117cc7f
* removing casualties of battle of the wits and English language
romansh
parents:
1887
diff
changeset
|
283 |
723 | 284 /* decode ac coefs */ |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
285 static void dv_decode_ac(GetBitContext *gb, BlockInfo *mb, DCTELEM *block) |
723 | 286 { |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
287 int last_index = get_bits_size(gb); |
1064 | 288 const uint8_t *scan_table = mb->scan_table; |
289 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
|
290 const int *iweight_table = mb->iweight_table; |
725 | 291 int pos = mb->pos; |
1905
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
292 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
|
293 int level, pos1, run, vlc_len, index; |
2967 | 294 |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
295 OPEN_READER(re, gb); |
1905
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
296 UPDATE_CACHE(re, gb); |
2967 | 297 |
723 | 298 /* if we must parse a partial vlc, we do it here */ |
299 if (partial_bit_count > 0) { | |
1905
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
300 re_cache = ((unsigned)re_cache >> partial_bit_count) | |
2979 | 301 (mb->partial_bit_buffer << (sizeof(re_cache)*8 - partial_bit_count)); |
302 re_index -= partial_bit_count; | |
303 mb->partial_bit_count = 0; | |
723 | 304 } |
305 | |
306 /* get the AC coefficients until last_index is reached */ | |
307 for(;;) { | |
308 #ifdef VLC_DEBUG | |
1905
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
309 printf("%2d: bits=%04x index=%d\n", pos, SHOW_UBITS(re, gb, 16), re_index); |
723 | 310 #endif |
1905
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
311 /* our own optimized GET_RL_VLC */ |
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
312 index = NEG_USR32(re_cache, TEX_VLC_BITS); |
2979 | 313 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
|
314 if (vlc_len < 0) { |
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
315 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
|
316 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
|
317 } |
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
318 level = dv_rl_vlc[index].level; |
2979 | 319 run = dv_rl_vlc[index].run; |
2967 | 320 |
2979 | 321 /* gotta check if we're still within gb boundaries */ |
322 if (re_index + vlc_len > last_index) { | |
323 /* should be < 16 bits otherwise a codeword could have been parsed */ | |
324 mb->partial_bit_count = last_index - re_index; | |
325 mb->partial_bit_buffer = NEG_USR32(re_cache, mb->partial_bit_count); | |
326 re_index = last_index; | |
327 break; | |
328 } | |
329 re_index += vlc_len; | |
1905
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
330 |
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
331 #ifdef VLC_DEBUG |
2979 | 332 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
|
333 #endif |
2979 | 334 pos += run; |
335 if (pos >= 64) | |
336 break; | |
2967 | 337 |
2847 | 338 pos1 = scan_table[pos]; |
3149
2679184e8be0
AC coefficient weighing (per SMPTE 314M) for the DV encoder and decoder. The
romansh
parents:
3148
diff
changeset
|
339 level <<= shift_table[pos1]; |
2679184e8be0
AC coefficient weighing (per SMPTE 314M) for the DV encoder and decoder. The
romansh
parents:
3148
diff
changeset
|
340 |
2679184e8be0
AC coefficient weighing (per SMPTE 314M) for the DV encoder and decoder. The
romansh
parents:
3148
diff
changeset
|
341 /* unweigh, round, and shift down */ |
2679184e8be0
AC coefficient weighing (per SMPTE 314M) for the DV encoder and decoder. The
romansh
parents:
3148
diff
changeset
|
342 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
|
343 |
2679184e8be0
AC coefficient weighing (per SMPTE 314M) for the DV encoder and decoder. The
romansh
parents:
3148
diff
changeset
|
344 block[pos1] = level; |
1905
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
345 |
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
346 UPDATE_CACHE(re, gb); |
723 | 347 } |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
348 CLOSE_READER(re, gb); |
725 | 349 mb->pos = pos; |
723 | 350 } |
351 | |
1886
fbcf02596520
* DV decoder simplifications. Now it looks to be 6% faster. At least
romansh
parents:
1875
diff
changeset
|
352 static inline void bit_copy(PutBitContext *pb, GetBitContext *gb) |
723 | 353 { |
1886
fbcf02596520
* DV decoder simplifications. Now it looks to be 6% faster. At least
romansh
parents:
1875
diff
changeset
|
354 int bits_left = get_bits_left(gb); |
2847 | 355 while (bits_left >= MIN_CACHE_BITS) { |
356 put_bits(pb, MIN_CACHE_BITS, get_bits(gb, MIN_CACHE_BITS)); | |
357 bits_left -= MIN_CACHE_BITS; | |
723 | 358 } |
359 if (bits_left > 0) { | |
360 put_bits(pb, bits_left, get_bits(gb, bits_left)); | |
361 } | |
362 } | |
363 | |
364 /* mb_x and mb_y are in units of 8 pixels */ | |
2967 | 365 static inline void dv_decode_video_segment(DVVideoContext *s, |
366 uint8_t *buf_ptr1, | |
1064 | 367 const uint16_t *mb_pos_ptr) |
723 | 368 { |
369 int quant, dc, dct_mode, class1, j; | |
370 int mb_index, mb_x, mb_y, v, last_index; | |
371 DCTELEM *block, *block1; | |
1886
fbcf02596520
* DV decoder simplifications. Now it looks to be 6% faster. At least
romansh
parents:
1875
diff
changeset
|
372 int c_offset; |
1064 | 373 uint8_t *y_ptr; |
374 void (*idct_put)(uint8_t *dest, int line_size, DCTELEM *block); | |
375 uint8_t *buf_ptr; | |
723 | 376 PutBitContext pb, vs_pb; |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
377 GetBitContext gb; |
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
378 BlockInfo mb_data[5 * 6], *mb, *mb1; |
3089 | 379 DECLARE_ALIGNED_8(DCTELEM, sblock[5*6][64]); |
380 DECLARE_ALIGNED_8(uint8_t, mb_bit_buffer[80 + 4]); /* allow some slack */ | |
381 DECLARE_ALIGNED_8(uint8_t, vs_bit_buffer[5 * 80 + 4]); /* allow some slack */ | |
2849 | 382 const int log2_blocksize= 3-s->avctx->lowres; |
2967 | 383 |
2847 | 384 assert((((int)mb_bit_buffer)&7)==0); |
385 assert((((int)vs_bit_buffer)&7)==0); | |
2967 | 386 |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
387 memset(sblock, 0, sizeof(sblock)); |
723 | 388 |
389 /* pass 1 : read DC and AC coefficients in blocks */ | |
390 buf_ptr = buf_ptr1; | |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
391 block1 = &sblock[0][0]; |
725 | 392 mb1 = mb_data; |
1522
79dddc5cd990
removed the obsolete and unused parameters of init_put_bits
alex
parents:
1507
diff
changeset
|
393 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
|
394 for(mb_index = 0; mb_index < 5; mb_index++, mb1 += 6, block1 += 6 * 64) { |
723 | 395 /* skip header */ |
396 quant = buf_ptr[3] & 0x0f; | |
397 buf_ptr += 4; | |
1522
79dddc5cd990
removed the obsolete and unused parameters of init_put_bits
alex
parents:
1507
diff
changeset
|
398 init_put_bits(&pb, mb_bit_buffer, 80); |
725 | 399 mb = mb1; |
723 | 400 block = block1; |
401 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
|
402 last_index = block_sizes[j]; |
2979 | 403 init_get_bits(&gb, buf_ptr, last_index); |
2967 | 404 |
723 | 405 /* get the dc */ |
2247 | 406 dc = get_sbits(&gb, 9); |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
407 dct_mode = get_bits1(&gb); |
725 | 408 mb->dct_mode = dct_mode; |
409 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
|
410 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
|
411 class1 = get_bits(&gb, 2); |
1905
2761950695cc
* some significant clean-up of the dv_decode_ac (it looks real
romansh
parents:
1904
diff
changeset
|
412 mb->shift_table = s->dv_idct_shift[class1 == 3][dct_mode] |
723 | 413 [quant + dv_quant_offset[class1]]; |
414 dc = dc << 2; | |
415 /* convert to unsigned because 128 is not added in the | |
416 standard IDCT */ | |
417 dc += 1024; | |
418 block[0] = dc; | |
419 buf_ptr += last_index >> 3; | |
725 | 420 mb->pos = 0; |
421 mb->partial_bit_count = 0; | |
723 | 422 |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
423 #ifdef VLC_DEBUG |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
424 printf("MB block: %d, %d ", mb_index, j); |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
425 #endif |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
426 dv_decode_ac(&gb, mb, block); |
723 | 427 |
428 /* write the remaining bits in a new buffer only if the | |
429 block is finished */ | |
1886
fbcf02596520
* DV decoder simplifications. Now it looks to be 6% faster. At least
romansh
parents:
1875
diff
changeset
|
430 if (mb->pos >= 64) |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
431 bit_copy(&pb, &gb); |
2967 | 432 |
723 | 433 block += 64; |
725 | 434 mb++; |
723 | 435 } |
2967 | 436 |
723 | 437 /* pass 2 : we can do it just after */ |
438 #ifdef VLC_DEBUG | |
1886
fbcf02596520
* DV decoder simplifications. Now it looks to be 6% faster. At least
romansh
parents:
1875
diff
changeset
|
439 printf("***pass 2 size=%d MB#=%d\n", put_bits_count(&pb), mb_index); |
723 | 440 #endif |
441 block = block1; | |
725 | 442 mb = mb1; |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
443 init_get_bits(&gb, mb_bit_buffer, put_bits_count(&pb)); |
2979 | 444 flush_put_bits(&pb); |
1886
fbcf02596520
* DV decoder simplifications. Now it looks to be 6% faster. At least
romansh
parents:
1875
diff
changeset
|
445 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
|
446 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
|
447 dv_decode_ac(&gb, mb, block); |
723 | 448 /* 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
|
449 if (mb->pos < 64) |
fbcf02596520
* DV decoder simplifications. Now it looks to be 6% faster. At least
romansh
parents:
1875
diff
changeset
|
450 break; |
723 | 451 } |
452 } | |
453 /* all blocks are finished, so the extra bytes can be used at | |
454 the video segment level */ | |
1886
fbcf02596520
* DV decoder simplifications. Now it looks to be 6% faster. At least
romansh
parents:
1875
diff
changeset
|
455 if (j >= 6) |
2979 | 456 bit_copy(&vs_pb, &gb); |
723 | 457 } |
458 | |
459 /* we need a pass other the whole video segment */ | |
460 #ifdef VLC_DEBUG | |
1886
fbcf02596520
* DV decoder simplifications. Now it looks to be 6% faster. At least
romansh
parents:
1875
diff
changeset
|
461 printf("***pass 3 size=%d\n", put_bits_count(&vs_pb)); |
723 | 462 #endif |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
463 block = &sblock[0][0]; |
723 | 464 mb = mb_data; |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
465 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
|
466 flush_put_bits(&vs_pb); |
723 | 467 for(mb_index = 0; mb_index < 5; mb_index++) { |
468 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
|
469 if (mb->pos < 64) { |
723 | 470 #ifdef VLC_DEBUG |
471 printf("start %d:%d\n", mb_index, j); | |
472 #endif | |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
473 dv_decode_ac(&gb, mb, block); |
723 | 474 } |
2979 | 475 if (mb->pos >= 64 && mb->pos < 127) |
476 av_log(NULL, AV_LOG_ERROR, "AC EOB marker is absent pos=%d\n", mb->pos); | |
723 | 477 block += 64; |
725 | 478 mb++; |
723 | 479 } |
480 } | |
2967 | 481 |
723 | 482 /* compute idct and place blocks */ |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
483 block = &sblock[0][0]; |
723 | 484 mb = mb_data; |
485 for(mb_index = 0; mb_index < 5; mb_index++) { | |
486 v = *mb_pos_ptr++; | |
487 mb_x = v & 0xff; | |
488 mb_y = v >> 8; | |
3167 | 489 if (s->sys->pix_fmt == PIX_FMT_YUV422P) { |
490 y_ptr = s->picture.data[0] + ((mb_y * s->picture.linesize[0] + (mb_x>>1))<<log2_blocksize); | |
2849 | 491 c_offset = ((mb_y * s->picture.linesize[1] + (mb_x >> 2))<<log2_blocksize); |
3167 | 492 } else { /* 4:1:1 or 4:2:0 */ |
493 y_ptr = s->picture.data[0] + ((mb_y * s->picture.linesize[0] + mb_x)<<log2_blocksize); | |
494 if (s->sys->pix_fmt == PIX_FMT_YUV411P) | |
495 c_offset = ((mb_y * s->picture.linesize[1] + (mb_x >> 2))<<log2_blocksize); | |
496 else /* 4:2:0 */ | |
497 c_offset = (((mb_y >> 1) * s->picture.linesize[1] + (mb_x >> 1))<<log2_blocksize); | |
498 } | |
723 | 499 for(j = 0;j < 6; j++) { |
2849 | 500 idct_put = s->idct_put[mb->dct_mode && log2_blocksize==3]; |
3167 | 501 if (s->sys->pix_fmt == PIX_FMT_YUV422P) { /* 4:2:2 */ |
502 if (j == 0 || j == 2) { | |
503 /* Y0 Y1 */ | |
504 idct_put(y_ptr + ((j >> 1)<<log2_blocksize), | |
1489
337d13aee605
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
1416
diff
changeset
|
505 s->picture.linesize[0], block); |
3167 | 506 } else if(j > 3) { |
507 /* Cr Cb */ | |
508 idct_put(s->picture.data[6 - j] + c_offset, | |
509 s->picture.linesize[6 - j], block); | |
723 | 510 } |
3167 | 511 /* note: j=1 and j=3 are "dummy" blocks in 4:2:2 */ |
512 } else { /* 4:1:1 or 4:2:0 */ | |
513 if (j < 4) { | |
514 if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x < (704 / 8)) { | |
515 /* NOTE: at end of line, the macroblock is handled as 420 */ | |
516 idct_put(y_ptr + (j<<log2_blocksize), s->picture.linesize[0], block); | |
517 } else { | |
518 idct_put(y_ptr + (((j & 1) + (j >> 1) * s->picture.linesize[0])<<log2_blocksize), | |
519 s->picture.linesize[0], block); | |
737 | 520 } |
521 } else { | |
3167 | 522 if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) { |
523 uint64_t aligned_pixels[64/8]; | |
524 uint8_t *pixels= (uint8_t*)aligned_pixels; | |
525 uint8_t *c_ptr, *c_ptr1, *ptr, *ptr1; | |
526 int x, y, linesize; | |
527 /* NOTE: at end of line, the macroblock is handled as 420 */ | |
528 idct_put(pixels, 8, block); | |
529 linesize = s->picture.linesize[6 - j]; | |
530 c_ptr = s->picture.data[6 - j] + c_offset; | |
531 ptr = pixels; | |
532 for(y = 0;y < (1<<log2_blocksize); y++) { | |
533 ptr1= ptr + (1<<(log2_blocksize-1)); | |
534 c_ptr1 = c_ptr + (linesize<<log2_blocksize); | |
535 for(x=0; x < (1<<(log2_blocksize-1)); x++){ | |
536 c_ptr[x]= ptr[x]; c_ptr1[x]= ptr1[x]; | |
537 } | |
538 c_ptr += linesize; | |
539 ptr += 8; | |
540 } | |
541 } else { | |
542 /* don't ask me why they inverted Cb and Cr ! */ | |
543 idct_put(s->picture.data[6 - j] + c_offset, | |
544 s->picture.linesize[6 - j], block); | |
545 } | |
737 | 546 } |
723 | 547 } |
548 block += 64; | |
725 | 549 mb++; |
723 | 550 } |
551 } | |
552 } | |
553 | |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
554 #ifdef DV_CODEC_TINY_TARGET |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
555 /* Converts run and level (where level != 0) pair into vlc, returning bit size */ |
4283
d6f83e2f8804
rename always_inline to av_always_inline and move to common.h
mru
parents:
4001
diff
changeset
|
556 static av_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
|
557 { |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
558 int size; |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
559 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
|
560 *vlc = dv_vlc_map[run][level].vlc | sign; |
2979 | 561 size = dv_vlc_map[run][level].size; |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
562 } |
2967 | 563 else { |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
564 if (level < DV_VLC_MAP_LEV_SIZE) { |
2979 | 565 *vlc = dv_vlc_map[0][level].vlc | sign; |
566 size = dv_vlc_map[0][level].size; | |
567 } else { | |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
568 *vlc = 0xfe00 | (level << 1) | sign; |
2979 | 569 size = 16; |
570 } | |
571 if (run) { | |
572 *vlc |= ((run < 16) ? dv_vlc_map[run-1][0].vlc : | |
573 (0x1f80 | (run - 1))) << size; | |
574 size += (run < 16) ? dv_vlc_map[run-1][0].size : 13; | |
575 } | |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
576 } |
2967 | 577 |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
578 return size; |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
579 } |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
580 |
4283
d6f83e2f8804
rename always_inline to av_always_inline and move to common.h
mru
parents:
4001
diff
changeset
|
581 static av_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
|
582 { |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
583 int size; |
2967 | 584 |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
585 if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) { |
2979 | 586 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
|
587 } |
2967 | 588 else { |
2979 | 589 size = (level < DV_VLC_MAP_LEV_SIZE) ? dv_vlc_map[0][level].size : 16; |
590 if (run) { | |
591 size += (run < 16) ? dv_vlc_map[run-1][0].size : 13; | |
592 } | |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
593 } |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
594 return size; |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
595 } |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
596 #else |
4283
d6f83e2f8804
rename always_inline to av_always_inline and move to common.h
mru
parents:
4001
diff
changeset
|
597 static av_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
|
598 { |
2847 | 599 *vlc = dv_vlc_map[run][l].vlc | sign; |
600 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
|
601 } |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
602 |
4283
d6f83e2f8804
rename always_inline to av_always_inline and move to common.h
mru
parents:
4001
diff
changeset
|
603 static av_always_inline int dv_rl2vlc_size(int run, int l) |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
604 { |
2847 | 605 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
|
606 } |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
607 #endif |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
608 |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
609 typedef struct EncBlockInfo { |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
610 int area_q[4]; |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
611 int bit_size[4]; |
2847 | 612 int prev[5]; |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
613 int cur_ac; |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
614 int cno; |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
615 int dct_mode; |
2847 | 616 DCTELEM mb[64]; |
617 uint8_t next[64]; | |
618 uint8_t sign[64]; | |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
619 uint8_t partial_bit_count; |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
620 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
|
621 } EncBlockInfo; |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
622 |
4283
d6f83e2f8804
rename always_inline to av_always_inline and move to common.h
mru
parents:
4001
diff
changeset
|
623 static av_always_inline PutBitContext* dv_encode_ac(EncBlockInfo* bi, PutBitContext* pb_pool, |
2847 | 624 PutBitContext* pb_end) |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
625 { |
2847 | 626 int prev; |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
627 int bits_left; |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
628 PutBitContext* pb = pb_pool; |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
629 int size = bi->partial_bit_count; |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
630 uint32_t vlc = bi->partial_bit_buffer; |
2847 | 631 |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
632 bi->partial_bit_count = bi->partial_bit_buffer = 0; |
2847 | 633 for(;;){ |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
634 /* Find suitable storage space */ |
1875
45a1592dadca
* moving some of the commonly used bit reading/writing functions
romansh
parents:
1726
diff
changeset
|
635 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
|
636 if (bits_left) { |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
637 size -= bits_left; |
2979 | 638 put_bits(pb, bits_left, vlc >> size); |
639 vlc = vlc & ((1<<size)-1); | |
640 } | |
641 if (pb + 1 >= pb_end) { | |
642 bi->partial_bit_count = size; | |
643 bi->partial_bit_buffer = vlc; | |
644 return pb; | |
645 } | |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
646 } |
2967 | 647 |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
648 /* Store VLC */ |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
649 put_bits(pb, size, vlc); |
2967 | 650 |
2847 | 651 if(bi->cur_ac>=64) |
652 break; | |
2967 | 653 |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
654 /* Construct the next VLC */ |
2847 | 655 prev= bi->cur_ac; |
656 bi->cur_ac = bi->next[prev]; | |
657 if(bi->cur_ac < 64){ | |
658 size = dv_rl2vlc(bi->cur_ac - prev - 1, bi->mb[bi->cur_ac], bi->sign[bi->cur_ac], &vlc); | |
659 } else { | |
660 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
|
661 } |
2847 | 662 } |
663 return pb; | |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
664 } |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
665 |
4283
d6f83e2f8804
rename always_inline to av_always_inline and move to common.h
mru
parents:
4001
diff
changeset
|
666 static av_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
|
667 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
|
668 { |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
669 int i, area; |
3152
28a087ad41d1
Assign class 2 to most macroblocks by default, instead of a more conservative
romansh
parents:
3150
diff
changeset
|
670 /* 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
|
671 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
|
672 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
|
673 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
|
674 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
|
675 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
|
676 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
|
677 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
|
678 (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
|
679 |
28a087ad41d1
Assign class 2 to most macroblocks by default, instead of a more conservative
romansh
parents:
3150
diff
changeset
|
680 #if 0 /* SMPTE spec method */ |
2847 | 681 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
|
682 #else /* improved ffmpeg method */ |
28a087ad41d1
Assign class 2 to most macroblocks by default, instead of a more conservative
romansh
parents:
3150
diff
changeset
|
683 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
|
684 #endif |
28a087ad41d1
Assign class 2 to most macroblocks by default, instead of a more conservative
romansh
parents:
3150
diff
changeset
|
685 int max=classes[0]; |
2847 | 686 int prev=0; |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
687 |
2967 | 688 bi->mb[0] = blk[0]; |
689 | |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
690 for (area = 0; area < 4; area++) { |
2847 | 691 bi->prev[area] = prev; |
692 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
|
693 for (i=mb_area_start[area]; i<mb_area_start[area+1]; i++) { |
2847 | 694 int level = blk[zigzag_scan[i]]; |
2967 | 695 |
2847 | 696 if (level+15 > 30U) { |
697 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
|
698 /* 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
|
699 /* 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
|
700 AND the 2x doubling of the weights */ |
4001 | 701 level = (FFABS(level) * weight[i] + (1<<(dv_weight_bits+3))) >> (dv_weight_bits+4); |
3149
2679184e8be0
AC coefficient weighing (per SMPTE 314M) for the DV encoder and decoder. The
romansh
parents:
3148
diff
changeset
|
702 bi->mb[i] = level; |
2847 | 703 if(level>max) max= level; |
704 bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, level); | |
705 bi->next[prev]= i; | |
706 prev= i; | |
707 } | |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
708 } |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
709 } |
2847 | 710 bi->next[prev]= i; |
711 for(bi->cno = 0; max > classes[bi->cno]; bi->cno++); | |
712 | |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
713 bi->cno += bias; |
2967 | 714 |
2847 | 715 if (bi->cno >= 3) { |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
716 bi->cno = 3; |
2847 | 717 prev=0; |
718 i= bi->next[prev]; | |
719 for (area = 0; area < 4; area++) { | |
720 bi->prev[area] = prev; | |
721 bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :) | |
722 for (; i<mb_area_start[area+1]; i= bi->next[i]) { | |
723 bi->mb[i] >>=1; | |
2967 | 724 |
2847 | 725 if (bi->mb[i]) { |
726 bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, bi->mb[i]); | |
727 bi->next[prev]= i; | |
728 prev= i; | |
729 } | |
730 } | |
731 } | |
732 bi->next[prev]= i; | |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
733 } |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
734 } |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
735 |
2847 | 736 //FIXME replace this by dsputil |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
737 #define SC(x, y) ((s[x] - s[y]) ^ ((s[x] - s[y]) >> 7)) |
4283
d6f83e2f8804
rename always_inline to av_always_inline and move to common.h
mru
parents:
4001
diff
changeset
|
738 static av_always_inline int dv_guess_dct_mode(DCTELEM *blk) { |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
739 DCTELEM *s; |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
740 int score88 = 0; |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
741 int score248 = 0; |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
742 int i; |
2967 | 743 |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
744 /* 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
|
745 s = blk; |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
746 for(i=0; i<7; i++) { |
2967 | 747 score88 += SC(0, 8) + SC(1, 9) + SC(2, 10) + SC(3, 11) + |
2979 | 748 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
|
749 s += 8; |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
750 } |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
751 /* 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
|
752 s = blk; |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
753 for(i=0; i<6; i++) { |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
754 score248 += SC(0, 16) + SC(1,17) + SC(2, 18) + SC(3, 19) + |
2979 | 755 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
|
756 s += 8; |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
757 } |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
758 |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
759 return (score88 - score248 > -10); |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
760 } |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
761 |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
762 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
|
763 { |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
764 int size[5]; |
3140 | 765 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
|
766 EncBlockInfo* b; |
2847 | 767 |
3146
dcae1bde37ac
size[0-3] are not initialized (and can get random negative trash
michael
parents:
3143
diff
changeset
|
768 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
|
769 do { |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
770 b = blks; |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
771 for (i=0; i<5; i++) { |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
772 if (!qnos[i]) |
2979 | 773 continue; |
2967 | 774 |
2979 | 775 qnos[i]--; |
776 size[i] = 0; | |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
777 for (j=0; j<6; j++, b++) { |
2979 | 778 for (a=0; a<4; a++) { |
779 if (b->area_q[a] != dv_quant_shifts[qnos[i] + dv_quant_offset[b->cno]][a]) { | |
780 b->bit_size[a] = 1; // 4 areas 4 bits for EOB :) | |
781 b->area_q[a]++; | |
2847 | 782 prev= b->prev[a]; |
3147 | 783 assert(b->next[prev] >= mb_area_start[a+1] || b->mb[prev]); |
2847 | 784 for (k= b->next[prev] ; k<mb_area_start[a+1]; k= b->next[k]) { |
2979 | 785 b->mb[k] >>= 1; |
786 if (b->mb[k]) { | |
2847 | 787 b->bit_size[a] += dv_rl2vlc_size(k - prev - 1, b->mb[k]); |
2979 | 788 prev= k; |
2847 | 789 } else { |
3140 | 790 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
|
791 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
|
792 b->prev[a2] = prev; |
3140 | 793 assert(a2<4); |
794 assert(b->mb[b->next[k]]); | |
795 b->bit_size[a2] += dv_rl2vlc_size(b->next[k] - prev - 1, b->mb[b->next[k]]) | |
796 -dv_rl2vlc_size(b->next[k] - k - 1, b->mb[b->next[k]]); | |
3147 | 797 assert(b->prev[a2]==k && (a2+1 >= 4 || b->prev[a2+1]!=k)); |
798 b->prev[a2] = prev; | |
3140 | 799 } |
2847 | 800 b->next[prev] = b->next[k]; |
801 } | |
2979 | 802 } |
2847 | 803 b->prev[a+1]= prev; |
2979 | 804 } |
805 size[i] += b->bit_size[a]; | |
806 } | |
807 } | |
3142 | 808 if(vs_total_ac_bits >= size[0] + size[1] + size[2] + size[3] + size[4]) |
809 return; | |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
810 } |
3140 | 811 } while (qnos[0]|qnos[1]|qnos[2]|qnos[3]|qnos[4]); |
812 | |
813 | |
814 for(a=2; a==2 || vs_total_ac_bits < size[0]; a+=a){ | |
815 b = blks; | |
3143 | 816 size[0] = 5*6*4; //EOB |
3140 | 817 for (j=0; j<6*5; j++, b++) { |
818 prev= b->prev[0]; | |
819 for (k= b->next[prev]; k<64; k= b->next[k]) { | |
820 if(b->mb[k] < a && b->mb[k] > -a){ | |
821 b->next[prev] = b->next[k]; | |
822 }else{ | |
823 size[0] += dv_rl2vlc_size(k - prev - 1, b->mb[k]); | |
824 prev= k; | |
825 } | |
826 } | |
827 } | |
828 } | |
1567 | 829 } |
830 | |
2967 | 831 static inline void dv_encode_video_segment(DVVideoContext *s, |
832 uint8_t *dif, | |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
833 const uint16_t *mb_pos_ptr) |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
834 { |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
835 int mb_index, i, j, v; |
2967 | 836 int mb_x, mb_y, c_offset, linesize; |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
837 uint8_t* y_ptr; |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
838 uint8_t* data; |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
839 uint8_t* ptr; |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
840 int do_edge_wrap; |
4675
c23a5c8263bc
force 16-bytes alignement of block array, as needed by the implementation of ff_dct_sse2
gpoirier
parents:
4666
diff
changeset
|
841 DECLARE_ALIGNED_16(DCTELEM, block[64]); |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
842 EncBlockInfo enc_blks[5*6]; |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
843 PutBitContext pbs[5*6]; |
2967 | 844 PutBitContext* pb; |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
845 EncBlockInfo* enc_blk; |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
846 int vs_bit_size = 0; |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
847 int qnos[5]; |
2967 | 848 |
4675
c23a5c8263bc
force 16-bytes alignement of block array, as needed by the implementation of ff_dct_sse2
gpoirier
parents:
4666
diff
changeset
|
849 assert((((int)block) & 15) == 0); |
2967 | 850 |
1567 | 851 enc_blk = &enc_blks[0]; |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
852 pb = &pbs[0]; |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
853 for(mb_index = 0; mb_index < 5; mb_index++) { |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
854 v = *mb_pos_ptr++; |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
855 mb_x = v & 0xff; |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
856 mb_y = v >> 8; |
3167 | 857 if (s->sys->pix_fmt == PIX_FMT_YUV422P) { |
858 y_ptr = s->picture.data[0] + (mb_y * s->picture.linesize[0] * 8) + (mb_x * 4); | |
859 } else { /* 4:1:1 */ | |
860 y_ptr = s->picture.data[0] + (mb_y * s->picture.linesize[0] * 8) + (mb_x * 8); | |
861 } | |
862 if (s->sys->pix_fmt == PIX_FMT_YUV420P) { | |
863 c_offset = (((mb_y >> 1) * s->picture.linesize[1] * 8) + ((mb_x >> 1) * 8)); | |
864 } else { /* 4:2:2 or 4:1:1 */ | |
865 c_offset = ((mb_y * s->picture.linesize[1] * 8) + ((mb_x >> 2) * 8)); | |
866 } | |
2979 | 867 do_edge_wrap = 0; |
868 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
|
869 ptr = dif + mb_index*80 + 4; |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
870 for(j = 0;j < 6; j++) { |
3167 | 871 int dummy = 0; |
872 if (s->sys->pix_fmt == PIX_FMT_YUV422P) { /* 4:2:2 */ | |
873 if (j == 0 || j == 2) { | |
874 /* Y0 Y1 */ | |
875 data = y_ptr + ((j>>1) * 8); | |
876 linesize = s->picture.linesize[0]; | |
877 } else if (j > 3) { | |
878 /* Cr Cb */ | |
879 data = s->picture.data[6 - j] + c_offset; | |
880 linesize = s->picture.linesize[6 - j]; | |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
881 } else { |
3167 | 882 /* j=1 and j=3 are "dummy" blocks, used for AC data only */ |
883 data = 0; | |
884 linesize = 0; | |
885 dummy = 1; | |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
886 } |
3167 | 887 } else { /* 4:1:1 or 4:2:0 */ |
888 if (j < 4) { /* Four Y blocks */ | |
889 /* NOTE: at end of line, the macroblock is handled as 420 */ | |
890 if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x < (704 / 8)) { | |
891 data = y_ptr + (j * 8); | |
892 } else { | |
893 data = y_ptr + ((j & 1) * 8) + ((j >> 1) * 8 * s->picture.linesize[0]); | |
894 } | |
895 linesize = s->picture.linesize[0]; | |
896 } else { /* Cr and Cb blocks */ | |
897 /* don't ask Fabrice why they inverted Cb and Cr ! */ | |
898 data = s->picture.data[6 - j] + c_offset; | |
899 linesize = s->picture.linesize[6 - j]; | |
900 if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) | |
901 do_edge_wrap = 1; | |
902 } | |
2979 | 903 } |
2967 | 904 |
2979 | 905 /* Everything is set up -- now just copy data -> DCT block */ |
906 if (do_edge_wrap) { /* Edge wrap copy: 4x16 -> 8x8 */ | |
907 uint8_t* d; | |
908 DCTELEM *b = block; | |
909 for (i=0;i<8;i++) { | |
910 d = data + 8 * linesize; | |
911 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
|
912 b[4] = d[0]; b[5] = d[1]; b[6] = d[2]; b[7] = d[3]; |
2979 | 913 data += linesize; |
914 b += 8; | |
915 } | |
916 } else { /* Simple copy: 8x8 -> 8x8 */ | |
3167 | 917 if (!dummy) |
918 s->get_pixels(block, data, linesize); | |
2979 | 919 } |
2967 | 920 |
2847 | 921 if(s->avctx->flags & CODEC_FLAG_INTERLACED_DCT) |
922 enc_blk->dct_mode = dv_guess_dct_mode(block); | |
923 else | |
924 enc_blk->dct_mode = 0; | |
2979 | 925 enc_blk->area_q[0] = enc_blk->area_q[1] = enc_blk->area_q[2] = enc_blk->area_q[3] = 0; |
926 enc_blk->partial_bit_count = 0; | |
927 enc_blk->partial_bit_buffer = 0; | |
928 enc_blk->cur_ac = 0; | |
2967 | 929 |
3167 | 930 if (dummy) { |
931 /* We rely on the fact that encoding all zeros leads to an immediate EOB, | |
932 which is precisely what the spec calls for in the "dummy" blocks. */ | |
933 memset(block, 0, sizeof(block)); | |
934 } else { | |
935 s->fdct[enc_blk->dct_mode](block); | |
936 } | |
2967 | 937 |
2979 | 938 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
|
939 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
|
940 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
|
941 j/4); |
2967 | 942 |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
943 init_put_bits(pb, ptr, block_sizes[j]/8); |
2979 | 944 put_bits(pb, 9, (uint16_t)(((enc_blk->mb[0] >> 3) - 1024 + 2) >> 2)); |
945 put_bits(pb, 1, enc_blk->dct_mode); | |
946 put_bits(pb, 2, enc_blk->cno); | |
2967 | 947 |
2979 | 948 vs_bit_size += enc_blk->bit_size[0] + enc_blk->bit_size[1] + |
949 enc_blk->bit_size[2] + enc_blk->bit_size[3]; | |
950 ++enc_blk; | |
951 ++pb; | |
952 ptr += block_sizes[j]/8; | |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
953 } |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
954 } |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
955 |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
956 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
|
957 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
|
958 |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
959 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
|
960 dif[i*80 + 3] = qnos[i]; |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
961 } |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
962 |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
963 /* First pass over individual cells only */ |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
964 for (j=0; j<5*6; j++) |
2847 | 965 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
|
966 |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
967 /* Second pass over each MB space */ |
2847 | 968 for (j=0; j<5*6; j+=6) { |
969 pb= &pbs[j]; | |
970 for (i=0; i<6; i++) { | |
971 if (enc_blks[i+j].partial_bit_count) | |
972 pb=dv_encode_ac(&enc_blks[i+j], pb, &pbs[j+6]); | |
973 } | |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
974 } |
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 /* Third and final pass over the whole vides segment space */ |
2847 | 977 pb= &pbs[0]; |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
978 for (j=0; j<5*6; j++) { |
2847 | 979 if (enc_blks[j].partial_bit_count) |
980 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
|
981 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
|
982 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
|
983 } |
1631
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
984 |
59f2fa833449
* 3x encoding speedup. Finally we seem to be on par with libdv
romansh
parents:
1598
diff
changeset
|
985 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
|
986 flush_put_bits(&pbs[j]); |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
987 } |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
988 |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
989 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
|
990 { |
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
991 DVVideoContext *s = avctx->priv_data; |
1904 | 992 int slice = (size_t)sl; |
3167 | 993 |
994 /* which DIF channel is this? */ | |
995 int chan = slice / (s->sys->difseg_size * 27); | |
996 | |
997 /* slice within the DIF channel */ | |
998 int chan_slice = slice % (s->sys->difseg_size * 27); | |
999 | |
1000 /* byte offset of this channel's data */ | |
1001 int chan_offset = chan * s->sys->difseg_size * 150 * 80; | |
1002 | |
1003 dv_decode_video_segment(s, &s->buf[((chan_slice/27)*6+(chan_slice/3)+chan_slice*5+7)*80 + chan_offset], | |
2979 | 1004 &s->sys->video_place[slice*5]); |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
1005 return 0; |
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
1006 } |
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
1007 |
3777 | 1008 #ifdef CONFIG_ENCODERS |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
1009 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
|
1010 { |
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
1011 DVVideoContext *s = avctx->priv_data; |
1904 | 1012 int slice = (size_t)sl; |
3167 | 1013 |
1014 /* which DIF channel is this? */ | |
1015 int chan = slice / (s->sys->difseg_size * 27); | |
1016 | |
1017 /* slice within the DIF channel */ | |
1018 int chan_slice = slice % (s->sys->difseg_size * 27); | |
1019 | |
1020 /* byte offset of this channel's data */ | |
1021 int chan_offset = chan * s->sys->difseg_size * 150 * 80; | |
1022 | |
1023 dv_encode_video_segment(s, &s->buf[((chan_slice/27)*6+(chan_slice/3)+chan_slice*5+7)*80 + chan_offset], | |
2979 | 1024 &s->sys->video_place[slice*5]); |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
1025 return 0; |
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
1026 } |
3777 | 1027 #endif |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
1028 |
3777 | 1029 #ifdef CONFIG_DECODERS |
723 | 1030 /* NOTE: exactly one frame must be given (120000 bytes for NTSC, |
3167 | 1031 144000 bytes for PAL - or twice those for 50Mbps) */ |
2967 | 1032 static int dvvideo_decode_frame(AVCodecContext *avctx, |
723 | 1033 void *data, int *data_size, |
1064 | 1034 uint8_t *buf, int buf_size) |
723 | 1035 { |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
1036 DVVideoContext *s = avctx->priv_data; |
2967 | 1037 |
1489
337d13aee605
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
1416
diff
changeset
|
1038 s->sys = dv_frame_profile(buf); |
337d13aee605
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
1416
diff
changeset
|
1039 if (!s->sys || buf_size < s->sys->frame_size) |
337d13aee605
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
1416
diff
changeset
|
1040 return -1; /* NOTE: we only accept several full frames */ |
723 | 1041 |
1228 | 1042 if(s->picture.data[0]) |
1043 avctx->release_buffer(avctx, &s->picture); | |
2967 | 1044 |
1489
337d13aee605
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
1416
diff
changeset
|
1045 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
|
1046 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
|
1047 s->picture.pict_type = FF_I_TYPE; |
1489
337d13aee605
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
1416
diff
changeset
|
1048 avctx->pix_fmt = s->sys->pix_fmt; |
2849 | 1049 avcodec_set_dimensions(avctx, s->sys->width, s->sys->height); |
903 | 1050 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
|
1051 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n"); |
903 | 1052 return -1; |
835 | 1053 } |
1543
7542cb99b950
* providing MPEG codecs with a generic fields in AVFrame to use.
romansh
parents:
1540
diff
changeset
|
1054 s->picture.interlaced_frame = 1; |
1547 | 1055 s->picture.top_field_first = 0; |
835 | 1056 |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
1057 s->buf = buf; |
3016
97e6c0f82182
Moving dv_anchor back to the global scope. This creates a tiny memory
romansh
parents:
2991
diff
changeset
|
1058 avctx->execute(avctx, dv_decode_mt, (void**)&dv_anchor[0], NULL, |
3167 | 1059 s->sys->n_difchan * s->sys->difseg_size * 27); |
2967 | 1060 |
734
2d6b3e3d6c6f
10l - MMX/FPU state was not restored, causing nonsense fpu behaviour in caller (mplayer)
arpi_esp
parents:
733
diff
changeset
|
1061 emms_c(); |
2d6b3e3d6c6f
10l - MMX/FPU state was not restored, causing nonsense fpu behaviour in caller (mplayer)
arpi_esp
parents:
733
diff
changeset
|
1062 |
723 | 1063 /* return image */ |
925 | 1064 *data_size = sizeof(AVFrame); |
1065 *(AVFrame*)data= s->picture; | |
2967 | 1066 |
1489
337d13aee605
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
1416
diff
changeset
|
1067 return s->sys->frame_size; |
723 | 1068 } |
3777 | 1069 #endif |
723 | 1070 |
3671
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1071 |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1072 static inline int dv_write_pack(enum dv_pack_type pack_id, DVVideoContext *c, uint8_t* buf) |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1073 { |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1074 /* |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1075 * Here's what SMPTE314M says about these two: |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1076 * (page 6) APTn, AP1n, AP2n, AP3n: These data shall be identical |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1077 * as track application IDs (APTn = 001, AP1n = |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1078 * 001, AP2n = 001, AP3n = 001), if the source signal |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1079 * comes from a digital VCR. If the signal source is |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1080 * unknown, all bits for these data shall be set to 1. |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1081 * (page 12) STYPE: STYPE defines a signal type of video signal |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1082 * 00000b = 4:1:1 compression |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1083 * 00100b = 4:2:2 compression |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1084 * XXXXXX = Reserved |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1085 * Now, I've got two problems with these statements: |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1086 * 1. it looks like APT == 111b should be a safe bet, but it isn't. |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1087 * It seems that for PAL as defined in IEC 61834 we have to set |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1088 * APT to 000 and for SMPTE314M to 001. |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1089 * 2. It is not at all clear what STYPE is used for 4:2:0 PAL |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1090 * compression scheme (if any). |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1091 */ |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1092 int apt = (c->sys->pix_fmt == PIX_FMT_YUV420P ? 0 : 1); |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1093 int stype = (c->sys->pix_fmt == PIX_FMT_YUV422P ? 4 : 0); |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1094 |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1095 uint8_t aspect = 0; |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1096 if((int)(av_q2d(c->avctx->sample_aspect_ratio) * c->avctx->width / c->avctx->height * 10) == 17) /* 16:9 */ |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1097 aspect = 0x02; |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1098 |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1099 buf[0] = (uint8_t)pack_id; |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1100 switch (pack_id) { |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1101 case dv_header525: /* I can't imagine why these two weren't defined as real */ |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1102 case dv_header625: /* packs in SMPTE314M -- they definitely look like ones */ |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1103 buf[1] = 0xf8 | /* reserved -- always 1 */ |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1104 (apt & 0x07); /* APT: Track application ID */ |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1105 buf[2] = (0 << 7) | /* TF1: audio data is 0 - valid; 1 - invalid */ |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1106 (0x0f << 3) | /* reserved -- always 1 */ |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1107 (apt & 0x07); /* AP1: Audio application ID */ |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1108 buf[3] = (0 << 7) | /* TF2: video data is 0 - valid; 1 - invalid */ |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1109 (0x0f << 3) | /* reserved -- always 1 */ |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1110 (apt & 0x07); /* AP2: Video application ID */ |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1111 buf[4] = (0 << 7) | /* TF3: subcode(SSYB) is 0 - valid; 1 - invalid */ |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1112 (0x0f << 3) | /* reserved -- always 1 */ |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1113 (apt & 0x07); /* AP3: Subcode application ID */ |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1114 break; |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1115 case dv_video_source: |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1116 buf[1] = 0xff; /* reserved -- always 1 */ |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1117 buf[2] = (1 << 7) | /* B/W: 0 - b/w, 1 - color */ |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1118 (1 << 6) | /* following CLF is valid - 0, invalid - 1 */ |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1119 (3 << 4) | /* CLF: color frames id (see ITU-R BT.470-4) */ |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1120 0xf; /* reserved -- always 1 */ |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1121 buf[3] = (3 << 6) | /* reserved -- always 1 */ |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1122 (c->sys->dsf << 5) | /* system: 60fields/50fields */ |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1123 stype; /* signal type video compression */ |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1124 buf[4] = 0xff; /* VISC: 0xff -- no information */ |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1125 break; |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1126 case dv_video_control: |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1127 buf[1] = (0 << 6) | /* Copy generation management (CGMS) 0 -- free */ |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1128 0x3f; /* reserved -- always 1 */ |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1129 buf[2] = 0xc8 | /* reserved -- always b11001xxx */ |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1130 aspect; |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1131 buf[3] = (1 << 7) | /* Frame/field flag 1 -- frame, 0 -- field */ |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1132 (1 << 6) | /* First/second field flag 0 -- field 2, 1 -- field 1 */ |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1133 (1 << 5) | /* Frame change flag 0 -- same picture as before, 1 -- different */ |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1134 (1 << 4) | /* 1 - interlaced, 0 - noninterlaced */ |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1135 0xc; /* reserved -- always b1100 */ |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1136 buf[4] = 0xff; /* reserved -- always 1 */ |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1137 break; |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1138 default: |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1139 buf[1] = buf[2] = buf[3] = buf[4] = 0xff; |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1140 } |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1141 return 5; |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1142 } |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1143 |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1144 static void dv_format_frame(DVVideoContext* c, uint8_t* buf) |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1145 { |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1146 int chan, i, j, k; |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1147 |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1148 for (chan = 0; chan < c->sys->n_difchan; chan++) { |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1149 for (i = 0; i < c->sys->difseg_size; i++) { |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1150 memset(buf, 0xff, 80 * 6); /* First 6 DIF blocks are for control data */ |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1151 |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1152 /* DV header: 1DIF */ |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1153 buf += dv_write_dif_id(dv_sect_header, chan, i, 0, buf); |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1154 buf += dv_write_pack((c->sys->dsf ? dv_header625 : dv_header525), c, buf); |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1155 buf += 72; /* unused bytes */ |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1156 |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1157 /* DV subcode: 2DIFs */ |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1158 for (j = 0; j < 2; j++) { |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1159 buf += dv_write_dif_id(dv_sect_subcode, chan, i, j, buf); |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1160 for (k = 0; k < 6; k++) |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1161 buf += dv_write_ssyb_id(k, (i < c->sys->difseg_size/2), buf) + 5; |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1162 buf += 29; /* unused bytes */ |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1163 } |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1164 |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1165 /* DV VAUX: 3DIFS */ |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1166 for (j = 0; j < 3; j++) { |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1167 buf += dv_write_dif_id(dv_sect_vaux, chan, i, j, buf); |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1168 buf += dv_write_pack(dv_video_source, c, buf); |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1169 buf += dv_write_pack(dv_video_control, c, buf); |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1170 buf += 7*5; |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1171 buf += dv_write_pack(dv_video_source, c, buf); |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1172 buf += dv_write_pack(dv_video_control, c, buf); |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1173 buf += 4*5 + 2; /* unused bytes */ |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1174 } |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1175 |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1176 /* DV Audio/Video: 135 Video DIFs + 9 Audio DIFs */ |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1177 for (j = 0; j < 135; j++) { |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1178 if (j%15 == 0) { |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1179 memset(buf, 0xff, 80); |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1180 buf += dv_write_dif_id(dv_sect_audio, chan, i, j/15, buf); |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1181 buf += 77; /* audio control & shuffled PCM audio */ |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1182 } |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1183 buf += dv_write_dif_id(dv_sect_video, chan, i, j, buf); |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1184 buf += 77; /* 1 video macro block: 1 bytes control |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1185 4 * 14 bytes Y 8x8 data |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1186 10 bytes Cr 8x8 data |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1187 10 bytes Cb 8x8 data */ |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1188 } |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1189 } |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1190 } |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1191 } |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1192 |
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1193 |
3806 | 1194 #ifdef CONFIG_ENCODERS |
2967 | 1195 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
|
1196 void *data) |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
1197 { |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
1198 DVVideoContext *s = c->priv_data; |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
1199 |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
1200 s->sys = dv_codec_profile(c); |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
1201 if (!s->sys) |
2979 | 1202 return -1; |
2422 | 1203 if(buf_size < s->sys->frame_size) |
1204 return -1; | |
1205 | |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
1206 c->pix_fmt = s->sys->pix_fmt; |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
1207 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
|
1208 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
|
1209 s->picture.pict_type = FF_I_TYPE; |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
1210 |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
1211 s->buf = buf; |
3016
97e6c0f82182
Moving dv_anchor back to the global scope. This creates a tiny memory
romansh
parents:
2991
diff
changeset
|
1212 c->execute(c, dv_encode_mt, (void**)&dv_anchor[0], NULL, |
3167 | 1213 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
|
1214 |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
1215 emms_c(); |
3167 | 1216 |
3671
18113845d891
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
3649
diff
changeset
|
1217 dv_format_frame(s, buf); |
3167 | 1218 |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
1219 return s->sys->frame_size; |
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
1220 } |
3806 | 1221 #endif |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
1222 |
2991
d377b0788381
Fix DV memory leak and allow multiple instances patch by (Burkhard Plaum?)
michael
parents:
2979
diff
changeset
|
1223 static int dvvideo_close(AVCodecContext *c) |
d377b0788381
Fix DV memory leak and allow multiple instances patch by (Burkhard Plaum?)
michael
parents:
2979
diff
changeset
|
1224 { |
4352
0ee71c12734e
* Fixing a bug with incorrect bits set in AAUX source pack
romansh
parents:
4283
diff
changeset
|
1225 DVVideoContext *s = c->priv_data; |
0ee71c12734e
* Fixing a bug with incorrect bits set in AAUX source pack
romansh
parents:
4283
diff
changeset
|
1226 |
0ee71c12734e
* Fixing a bug with incorrect bits set in AAUX source pack
romansh
parents:
4283
diff
changeset
|
1227 if(s->picture.data[0]) |
0ee71c12734e
* Fixing a bug with incorrect bits set in AAUX source pack
romansh
parents:
4283
diff
changeset
|
1228 c->release_buffer(c, &s->picture); |
2991
d377b0788381
Fix DV memory leak and allow multiple instances patch by (Burkhard Plaum?)
michael
parents:
2979
diff
changeset
|
1229 |
d377b0788381
Fix DV memory leak and allow multiple instances patch by (Burkhard Plaum?)
michael
parents:
2979
diff
changeset
|
1230 return 0; |
d377b0788381
Fix DV memory leak and allow multiple instances patch by (Burkhard Plaum?)
michael
parents:
2979
diff
changeset
|
1231 } |
d377b0788381
Fix DV memory leak and allow multiple instances patch by (Burkhard Plaum?)
michael
parents:
2979
diff
changeset
|
1232 |
d377b0788381
Fix DV memory leak and allow multiple instances patch by (Burkhard Plaum?)
michael
parents:
2979
diff
changeset
|
1233 |
2661
b2846918585c
a few #ifdef CONFIG_X_ENCODER, patch by (Roine Gustafsson <roine users.sourceforge net]
michael
parents:
2614
diff
changeset
|
1234 #ifdef CONFIG_DVVIDEO_ENCODER |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
1235 AVCodec dvvideo_encoder = { |
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
1236 "dvvideo", |
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
1237 CODEC_TYPE_VIDEO, |
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
1238 CODEC_ID_DVVIDEO, |
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
1239 sizeof(DVVideoContext), |
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
1240 dvvideo_init, |
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
1241 dvvideo_encode_frame, |
4352
0ee71c12734e
* Fixing a bug with incorrect bits set in AAUX source pack
romansh
parents:
4283
diff
changeset
|
1242 .pix_fmts = (enum PixelFormat[]) {PIX_FMT_YUV411P, PIX_FMT_YUV422P, PIX_FMT_YUV420P, -1}, |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
1243 }; |
2661
b2846918585c
a few #ifdef CONFIG_X_ENCODER, patch by (Roine Gustafsson <roine users.sourceforge net]
michael
parents:
2614
diff
changeset
|
1244 #endif // CONFIG_DVVIDEO_ENCODER |
723 | 1245 |
3777 | 1246 #ifdef CONFIG_DVVIDEO_DECODER |
723 | 1247 AVCodec dvvideo_decoder = { |
1248 "dvvideo", | |
1249 CODEC_TYPE_VIDEO, | |
1250 CODEC_ID_DVVIDEO, | |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
1251 sizeof(DVVideoContext), |
1493
ad7e62df9962
* preAlpha DV encoding support -- there's still a truckload
romansh
parents:
1489
diff
changeset
|
1252 dvvideo_init, |
1887
85fe2f4633ec
* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)
romansh
parents:
1886
diff
changeset
|
1253 NULL, |
2991
d377b0788381
Fix DV memory leak and allow multiple instances patch by (Burkhard Plaum?)
michael
parents:
2979
diff
changeset
|
1254 dvvideo_close, |
723 | 1255 dvvideo_decode_frame, |
835 | 1256 CODEC_CAP_DR1, |
723 | 1257 NULL |
1258 }; | |
3777 | 1259 #endif |