Mercurial > libavcodec.hg
annotate svq1.c @ 2497:69adfbbdcdeb libavcodec
- samples from mplayer ftp in the "adv" profile seem to have profile=2,
which isn't the advanced one; and indeed, using adv. profile parser fails.
Using normal parser works, and that's what is done
- attempt at taking care of stride for NORM2 bitplane decoding
- duplication of much code from msmpeg4.c; this code isn't yet used, but
goes down as far as the block layer (mainly Transform Type stuff, the
remains are wild editing without checking). Unusable yet, and lacks the AC
decoding (but a step further in bitstream parsing)
patch by anonymous
author | michael |
---|---|
date | Fri, 04 Feb 2005 02:20:38 +0000 |
parents | f67b63ed036d |
children | e25782262d7d |
rev | line source |
---|---|
536
6fac683d9997
Change licence to LGPL since there are no objections from side of original author
nickols_k
parents:
530
diff
changeset
|
1 /* |
521 | 2 * |
536
6fac683d9997
Change licence to LGPL since there are no objections from side of original author
nickols_k
parents:
530
diff
changeset
|
3 * Copyright (C) 2002 the xine project |
6fac683d9997
Change licence to LGPL since there are no objections from side of original author
nickols_k
parents:
530
diff
changeset
|
4 * Copyright (C) 2002 the ffmpeg project |
521 | 5 * |
536
6fac683d9997
Change licence to LGPL since there are no objections from side of original author
nickols_k
parents:
530
diff
changeset
|
6 * This library is free software; you can redistribute it and/or |
6fac683d9997
Change licence to LGPL since there are no objections from side of original author
nickols_k
parents:
530
diff
changeset
|
7 * modify it under the terms of the GNU Lesser General Public |
6fac683d9997
Change licence to LGPL since there are no objections from side of original author
nickols_k
parents:
530
diff
changeset
|
8 * License as published by the Free Software Foundation; either |
6fac683d9997
Change licence to LGPL since there are no objections from side of original author
nickols_k
parents:
530
diff
changeset
|
9 * version 2 of the License, or (at your option) any later version. |
6fac683d9997
Change licence to LGPL since there are no objections from side of original author
nickols_k
parents:
530
diff
changeset
|
10 * |
6fac683d9997
Change licence to LGPL since there are no objections from side of original author
nickols_k
parents:
530
diff
changeset
|
11 * This library is distributed in the hope that it will be useful, |
521 | 12 * but WITHOUT ANY WARRANTY; without even the implied warranty of |
536
6fac683d9997
Change licence to LGPL since there are no objections from side of original author
nickols_k
parents:
530
diff
changeset
|
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
6fac683d9997
Change licence to LGPL since there are no objections from side of original author
nickols_k
parents:
530
diff
changeset
|
14 * Lesser General Public License for more details. |
6fac683d9997
Change licence to LGPL since there are no objections from side of original author
nickols_k
parents:
530
diff
changeset
|
15 * |
6fac683d9997
Change licence to LGPL since there are no objections from side of original author
nickols_k
parents:
530
diff
changeset
|
16 * You should have received a copy of the GNU Lesser General Public |
6fac683d9997
Change licence to LGPL since there are no objections from side of original author
nickols_k
parents:
530
diff
changeset
|
17 * License along with this library; if not, write to the Free Software |
6fac683d9997
Change licence to LGPL since there are no objections from side of original author
nickols_k
parents:
530
diff
changeset
|
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
6fac683d9997
Change licence to LGPL since there are no objections from side of original author
nickols_k
parents:
530
diff
changeset
|
19 * |
2005 | 20 * (SVQ1 Decoder) |
537 | 21 * Ported to mplayer by Arpi <arpi@thot.banki.hu> |
536
6fac683d9997
Change licence to LGPL since there are no objections from side of original author
nickols_k
parents:
530
diff
changeset
|
22 * Ported to libavcodec by Nick Kurshev <nickols_k@mail.ru> |
521 | 23 * |
2005 | 24 * SVQ1 Encoder (c) 2004 Mike Melanson <melanson@pcisys.net> |
521 | 25 */ |
1106 | 26 |
27 /** | |
28 * @file svq1.c | |
2005 | 29 * Sorenson Vector Quantizer #1 (SVQ1) video codec. |
30 * For more information of the SVQ1 algorithm, visit: | |
31 * http://www.pcisys.net/~melanson/codecs/ | |
1106 | 32 */ |
33 | |
1283
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
34 |
521 | 35 //#define DEBUG_SVQ1 |
36 #include <stdio.h> | |
37 #include <stdlib.h> | |
38 #include <string.h> | |
39 #include <unistd.h> | |
2007 | 40 #include <limits.h> |
521 | 41 |
528 | 42 #include "common.h" |
521 | 43 #include "avcodec.h" |
44 #include "dsputil.h" | |
45 #include "mpegvideo.h" | |
1283
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
46 #include "bswap.h" |
551 | 47 |
2007 | 48 #undef NDEBUG |
49 #include <assert.h> | |
50 | |
2017 | 51 extern const uint8_t mvtab[33][2]; |
52 | |
1283
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
53 static VLC svq1_block_type; |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
54 static VLC svq1_motion_component; |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
55 static VLC svq1_intra_multistage[6]; |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
56 static VLC svq1_inter_multistage[6]; |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
57 static VLC svq1_intra_mean; |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
58 static VLC svq1_inter_mean; |
521 | 59 |
60 #define SVQ1_BLOCK_SKIP 0 | |
61 #define SVQ1_BLOCK_INTER 1 | |
62 #define SVQ1_BLOCK_INTER_4V 2 | |
63 #define SVQ1_BLOCK_INTRA 3 | |
64 | |
2005 | 65 typedef struct SVQ1Context { |
2017 | 66 MpegEncContext m; // needed for motion estimation, should not be used for anything else, the idea is to make the motion estimation eventually independant of MpegEncContext, so this will be removed then (FIXME/XXX) |
2005 | 67 AVCodecContext *avctx; |
68 DSPContext dsp; | |
69 AVFrame picture; | |
2012
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
70 AVFrame current_picture; |
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
71 AVFrame last_picture; |
2005 | 72 PutBitContext pb; |
73 GetBitContext gb; | |
2007 | 74 |
75 PutBitContext reorder_pb[6]; //why ooh why this sick breadth first order, everything is slower and more complex | |
2005 | 76 |
77 int frame_width; | |
78 int frame_height; | |
79 | |
80 /* Y plane block dimensions */ | |
81 int y_block_width; | |
82 int y_block_height; | |
83 | |
84 /* U & V plane (C planes) block dimensions */ | |
85 int c_block_width; | |
86 int c_block_height; | |
2017 | 87 |
88 uint16_t *mb_type; | |
89 uint32_t *dummy; | |
90 int16_t (*motion_val8[3])[2]; | |
91 int16_t (*motion_val16[3])[2]; | |
2005 | 92 |
2010 | 93 int64_t rd_total; |
2005 | 94 } SVQ1Context; |
95 | |
521 | 96 /* motion vector (prediction) */ |
97 typedef struct svq1_pmv_s { | |
98 int x; | |
99 int y; | |
100 } svq1_pmv_t; | |
101 | |
579 | 102 #include "svq1_cb.h" |
1283
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
103 #include "svq1_vlc.h" |
521 | 104 |
1283
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
105 static const uint16_t checksum_table[256] = { |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
106 0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50A5, 0x60C6, 0x70E7, |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
107 0x8108, 0x9129, 0xA14A, 0xB16B, 0xC18C, 0xD1AD, 0xE1CE, 0xF1EF, |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
108 0x1231, 0x0210, 0x3273, 0x2252, 0x52B5, 0x4294, 0x72F7, 0x62D6, |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
109 0x9339, 0x8318, 0xB37B, 0xA35A, 0xD3BD, 0xC39C, 0xF3FF, 0xE3DE, |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
110 0x2462, 0x3443, 0x0420, 0x1401, 0x64E6, 0x74C7, 0x44A4, 0x5485, |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
111 0xA56A, 0xB54B, 0x8528, 0x9509, 0xE5EE, 0xF5CF, 0xC5AC, 0xD58D, |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
112 0x3653, 0x2672, 0x1611, 0x0630, 0x76D7, 0x66F6, 0x5695, 0x46B4, |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
113 0xB75B, 0xA77A, 0x9719, 0x8738, 0xF7DF, 0xE7FE, 0xD79D, 0xC7BC, |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
114 0x48C4, 0x58E5, 0x6886, 0x78A7, 0x0840, 0x1861, 0x2802, 0x3823, |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
115 0xC9CC, 0xD9ED, 0xE98E, 0xF9AF, 0x8948, 0x9969, 0xA90A, 0xB92B, |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
116 0x5AF5, 0x4AD4, 0x7AB7, 0x6A96, 0x1A71, 0x0A50, 0x3A33, 0x2A12, |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
117 0xDBFD, 0xCBDC, 0xFBBF, 0xEB9E, 0x9B79, 0x8B58, 0xBB3B, 0xAB1A, |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
118 0x6CA6, 0x7C87, 0x4CE4, 0x5CC5, 0x2C22, 0x3C03, 0x0C60, 0x1C41, |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
119 0xEDAE, 0xFD8F, 0xCDEC, 0xDDCD, 0xAD2A, 0xBD0B, 0x8D68, 0x9D49, |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
120 0x7E97, 0x6EB6, 0x5ED5, 0x4EF4, 0x3E13, 0x2E32, 0x1E51, 0x0E70, |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
121 0xFF9F, 0xEFBE, 0xDFDD, 0xCFFC, 0xBF1B, 0xAF3A, 0x9F59, 0x8F78, |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
122 0x9188, 0x81A9, 0xB1CA, 0xA1EB, 0xD10C, 0xC12D, 0xF14E, 0xE16F, |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
123 0x1080, 0x00A1, 0x30C2, 0x20E3, 0x5004, 0x4025, 0x7046, 0x6067, |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
124 0x83B9, 0x9398, 0xA3FB, 0xB3DA, 0xC33D, 0xD31C, 0xE37F, 0xF35E, |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
125 0x02B1, 0x1290, 0x22F3, 0x32D2, 0x4235, 0x5214, 0x6277, 0x7256, |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
126 0xB5EA, 0xA5CB, 0x95A8, 0x8589, 0xF56E, 0xE54F, 0xD52C, 0xC50D, |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
127 0x34E2, 0x24C3, 0x14A0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405, |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
128 0xA7DB, 0xB7FA, 0x8799, 0x97B8, 0xE75F, 0xF77E, 0xC71D, 0xD73C, |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
129 0x26D3, 0x36F2, 0x0691, 0x16B0, 0x6657, 0x7676, 0x4615, 0x5634, |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
130 0xD94C, 0xC96D, 0xF90E, 0xE92F, 0x99C8, 0x89E9, 0xB98A, 0xA9AB, |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
131 0x5844, 0x4865, 0x7806, 0x6827, 0x18C0, 0x08E1, 0x3882, 0x28A3, |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
132 0xCB7D, 0xDB5C, 0xEB3F, 0xFB1E, 0x8BF9, 0x9BD8, 0xABBB, 0xBB9A, |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
133 0x4A75, 0x5A54, 0x6A37, 0x7A16, 0x0AF1, 0x1AD0, 0x2AB3, 0x3A92, |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
134 0xFD2E, 0xED0F, 0xDD6C, 0xCD4D, 0xBDAA, 0xAD8B, 0x9DE8, 0x8DC9, |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
135 0x7C26, 0x6C07, 0x5C64, 0x4C45, 0x3CA2, 0x2C83, 0x1CE0, 0x0CC1, |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
136 0xEF1F, 0xFF3E, 0xCF5D, 0xDF7C, 0xAF9B, 0xBFBA, 0x8FD9, 0x9FF8, |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
137 0x6E17, 0x7E36, 0x4E55, 0x5E74, 0x2E93, 0x3EB2, 0x0ED1, 0x1EF0 |
521 | 138 }; |
139 | |
1283
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
140 static const uint8_t string_table[256] = { |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
141 0x00, 0xD5, 0x7F, 0xAA, 0xFE, 0x2B, 0x81, 0x54, |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
142 0x29, 0xFC, 0x56, 0x83, 0xD7, 0x02, 0xA8, 0x7D, |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
143 0x52, 0x87, 0x2D, 0xF8, 0xAC, 0x79, 0xD3, 0x06, |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
144 0x7B, 0xAE, 0x04, 0xD1, 0x85, 0x50, 0xFA, 0x2F, |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
145 0xA4, 0x71, 0xDB, 0x0E, 0x5A, 0x8F, 0x25, 0xF0, |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
146 0x8D, 0x58, 0xF2, 0x27, 0x73, 0xA6, 0x0C, 0xD9, |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
147 0xF6, 0x23, 0x89, 0x5C, 0x08, 0xDD, 0x77, 0xA2, |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
148 0xDF, 0x0A, 0xA0, 0x75, 0x21, 0xF4, 0x5E, 0x8B, |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
149 0x9D, 0x48, 0xE2, 0x37, 0x63, 0xB6, 0x1C, 0xC9, |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
150 0xB4, 0x61, 0xCB, 0x1E, 0x4A, 0x9F, 0x35, 0xE0, |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
151 0xCF, 0x1A, 0xB0, 0x65, 0x31, 0xE4, 0x4E, 0x9B, |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
152 0xE6, 0x33, 0x99, 0x4C, 0x18, 0xCD, 0x67, 0xB2, |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
153 0x39, 0xEC, 0x46, 0x93, 0xC7, 0x12, 0xB8, 0x6D, |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
154 0x10, 0xC5, 0x6F, 0xBA, 0xEE, 0x3B, 0x91, 0x44, |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
155 0x6B, 0xBE, 0x14, 0xC1, 0x95, 0x40, 0xEA, 0x3F, |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
156 0x42, 0x97, 0x3D, 0xE8, 0xBC, 0x69, 0xC3, 0x16, |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
157 0xEF, 0x3A, 0x90, 0x45, 0x11, 0xC4, 0x6E, 0xBB, |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
158 0xC6, 0x13, 0xB9, 0x6C, 0x38, 0xED, 0x47, 0x92, |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
159 0xBD, 0x68, 0xC2, 0x17, 0x43, 0x96, 0x3C, 0xE9, |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
160 0x94, 0x41, 0xEB, 0x3E, 0x6A, 0xBF, 0x15, 0xC0, |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
161 0x4B, 0x9E, 0x34, 0xE1, 0xB5, 0x60, 0xCA, 0x1F, |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
162 0x62, 0xB7, 0x1D, 0xC8, 0x9C, 0x49, 0xE3, 0x36, |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
163 0x19, 0xCC, 0x66, 0xB3, 0xE7, 0x32, 0x98, 0x4D, |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
164 0x30, 0xE5, 0x4F, 0x9A, 0xCE, 0x1B, 0xB1, 0x64, |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
165 0x72, 0xA7, 0x0D, 0xD8, 0x8C, 0x59, 0xF3, 0x26, |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
166 0x5B, 0x8E, 0x24, 0xF1, 0xA5, 0x70, 0xDA, 0x0F, |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
167 0x20, 0xF5, 0x5F, 0x8A, 0xDE, 0x0B, 0xA1, 0x74, |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
168 0x09, 0xDC, 0x76, 0xA3, 0xF7, 0x22, 0x88, 0x5D, |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
169 0xD6, 0x03, 0xA9, 0x7C, 0x28, 0xFD, 0x57, 0x82, |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
170 0xFF, 0x2A, 0x80, 0x55, 0x01, 0xD4, 0x7E, 0xAB, |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
171 0x84, 0x51, 0xFB, 0x2E, 0x7A, 0xAF, 0x05, 0xD0, |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
172 0xAD, 0x78, 0xD2, 0x07, 0x53, 0x86, 0x2C, 0xF9 |
521 | 173 }; |
174 | |
528 | 175 #define SVQ1_PROCESS_VECTOR()\ |
176 for (; level > 0; i++) {\ | |
177 /* process next depth */\ | |
178 if (i == m) {\ | |
179 m = n;\ | |
180 if (--level == 0)\ | |
181 break;\ | |
182 }\ | |
183 /* divide block if next bit set */\ | |
184 if (get_bits (bitbuf, 1) == 0)\ | |
185 break;\ | |
186 /* add child nodes */\ | |
187 list[n++] = list[i];\ | |
188 list[n++] = list[i] + (((level & 1) ? pitch : 1) << ((level / 2) + 1));\ | |
189 } | |
521 | 190 |
528 | 191 #define SVQ1_ADD_CODEBOOK()\ |
192 /* add codebook entries to vector */\ | |
193 for (j=0; j < stages; j++) {\ | |
194 n3 = codebook[entries[j]] ^ 0x80808080;\ | |
195 n1 += ((n3 & 0xFF00FF00) >> 8);\ | |
196 n2 += (n3 & 0x00FF00FF);\ | |
197 }\ | |
198 \ | |
199 /* clip to [0..255] */\ | |
200 if (n1 & 0xFF00FF00) {\ | |
201 n3 = ((( n1 >> 15) & 0x00010001) | 0x01000100) - 0x00010001;\ | |
202 n1 += 0x7F007F00;\ | |
203 n1 |= (((~n1 >> 15) & 0x00010001) | 0x01000100) - 0x00010001;\ | |
204 n1 &= (n3 & 0x00FF00FF);\ | |
205 }\ | |
206 \ | |
207 if (n2 & 0xFF00FF00) {\ | |
208 n3 = ((( n2 >> 15) & 0x00010001) | 0x01000100) - 0x00010001;\ | |
209 n2 += 0x7F007F00;\ | |
210 n2 |= (((~n2 >> 15) & 0x00010001) | 0x01000100) - 0x00010001;\ | |
211 n2 &= (n3 & 0x00FF00FF);\ | |
212 } | |
213 | |
214 #define SVQ1_DO_CODEBOOK_INTRA()\ | |
215 for (y=0; y < height; y++) {\ | |
216 for (x=0; x < (width / 4); x++, codebook++) {\ | |
217 n1 = n4;\ | |
218 n2 = n4;\ | |
219 SVQ1_ADD_CODEBOOK()\ | |
220 /* store result */\ | |
221 dst[x] = (n1 << 8) | n2;\ | |
222 }\ | |
223 dst += (pitch / 4);\ | |
224 } | |
225 | |
226 #define SVQ1_DO_CODEBOOK_NONINTRA()\ | |
227 for (y=0; y < height; y++) {\ | |
228 for (x=0; x < (width / 4); x++, codebook++) {\ | |
229 n3 = dst[x];\ | |
230 /* add mean value to vector */\ | |
231 n1 = ((n3 & 0xFF00FF00) >> 8) + n4;\ | |
232 n2 = (n3 & 0x00FF00FF) + n4;\ | |
233 SVQ1_ADD_CODEBOOK()\ | |
234 /* store result */\ | |
235 dst[x] = (n1 << 8) | n2;\ | |
236 }\ | |
237 dst += (pitch / 4);\ | |
238 } | |
239 | |
240 #define SVQ1_CALC_CODEBOOK_ENTRIES(cbook)\ | |
862 | 241 codebook = (const uint32_t *) cbook[level];\ |
528 | 242 bit_cache = get_bits (bitbuf, 4*stages);\ |
243 /* calculate codebook entries for this vector */\ | |
244 for (j=0; j < stages; j++) {\ | |
245 entries[j] = (((bit_cache >> (4*(stages - j - 1))) & 0xF) + 16*j) << (level + 1);\ | |
246 }\ | |
247 mean -= (stages * 128);\ | |
248 n4 = ((mean + (mean >> 31)) << 16) | (mean & 0xFFFF); | |
249 | |
1283
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
250 static int svq1_decode_block_intra (GetBitContext *bitbuf, uint8_t *pixels, int pitch ) { |
521 | 251 uint32_t bit_cache; |
252 uint8_t *list[63]; | |
253 uint32_t *dst; | |
862 | 254 const uint32_t *codebook; |
521 | 255 int entries[6]; |
256 int i, j, m, n; | |
257 int mean, stages; | |
862 | 258 unsigned x, y, width, height, level; |
521 | 259 uint32_t n1, n2, n3, n4; |
260 | |
261 /* initialize list for breadth first processing of vectors */ | |
262 list[0] = pixels; | |
263 | |
264 /* recursively process vector */ | |
265 for (i=0, m=1, n=1, level=5; i < n; i++) { | |
528 | 266 SVQ1_PROCESS_VECTOR(); |
521 | 267 |
268 /* destination address and vector size */ | |
269 dst = (uint32_t *) list[i]; | |
270 width = 1 << ((4 + level) /2); | |
271 height = 1 << ((3 + level) /2); | |
272 | |
273 /* get number of stages (-1 skips vector, 0 for mean only) */ | |
1283
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
274 stages = get_vlc2(bitbuf, svq1_intra_multistage[level].table, 3, 3) - 1; |
521 | 275 |
276 if (stages == -1) { | |
277 for (y=0; y < height; y++) { | |
278 memset (&dst[y*(pitch / 4)], 0, width); | |
279 } | |
280 continue; /* skip vector */ | |
281 } | |
282 | |
283 if ((stages > 0) && (level >= 4)) { | |
284 #ifdef DEBUG_SVQ1 | |
2005 | 285 av_log(s->avctx, AV_LOG_INFO, "Error (svq1_decode_block_intra): invalid vector: stages=%i level=%i\n",stages,level); |
521 | 286 #endif |
287 return -1; /* invalid vector */ | |
288 } | |
289 | |
1283
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
290 mean = get_vlc2(bitbuf, svq1_intra_mean.table, 8, 3); |
521 | 291 |
528 | 292 if (stages == 0) { |
521 | 293 for (y=0; y < height; y++) { |
294 memset (&dst[y*(pitch / 4)], mean, width); | |
295 } | |
296 } else { | |
528 | 297 SVQ1_CALC_CODEBOOK_ENTRIES(svq1_intra_codebooks); |
298 SVQ1_DO_CODEBOOK_INTRA() | |
521 | 299 } |
300 } | |
301 | |
302 return 0; | |
303 } | |
304 | |
1283
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
305 static int svq1_decode_block_non_intra (GetBitContext *bitbuf, uint8_t *pixels, int pitch ) { |
528 | 306 uint32_t bit_cache; |
307 uint8_t *list[63]; | |
308 uint32_t *dst; | |
862 | 309 const uint32_t *codebook; |
528 | 310 int entries[6]; |
311 int i, j, m, n; | |
312 int mean, stages; | |
313 int x, y, width, height, level; | |
314 uint32_t n1, n2, n3, n4; | |
315 | |
316 /* initialize list for breadth first processing of vectors */ | |
317 list[0] = pixels; | |
318 | |
319 /* recursively process vector */ | |
320 for (i=0, m=1, n=1, level=5; i < n; i++) { | |
321 SVQ1_PROCESS_VECTOR(); | |
322 | |
323 /* destination address and vector size */ | |
324 dst = (uint32_t *) list[i]; | |
325 width = 1 << ((4 + level) /2); | |
326 height = 1 << ((3 + level) /2); | |
327 | |
328 /* get number of stages (-1 skips vector, 0 for mean only) */ | |
1283
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
329 stages = get_vlc2(bitbuf, svq1_inter_multistage[level].table, 3, 2) - 1; |
528 | 330 |
331 if (stages == -1) continue; /* skip vector */ | |
332 | |
333 if ((stages > 0) && (level >= 4)) { | |
334 #ifdef DEBUG_SVQ1 | |
2005 | 335 av_log(s->avctx, AV_LOG_INFO, "Error (svq1_decode_block_non_intra): invalid vector: stages=%i level=%i\n",stages,level); |
528 | 336 #endif |
337 return -1; /* invalid vector */ | |
338 } | |
339 | |
1283
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
340 mean = get_vlc2(bitbuf, svq1_inter_mean.table, 9, 3) - 256; |
528 | 341 |
342 SVQ1_CALC_CODEBOOK_ENTRIES(svq1_inter_codebooks); | |
343 SVQ1_DO_CODEBOOK_NONINTRA() | |
344 } | |
345 return 0; | |
346 } | |
347 | |
1283
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
348 static int svq1_decode_motion_vector (GetBitContext *bitbuf, svq1_pmv_t *mv, svq1_pmv_t **pmv) { |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
349 int diff; |
521 | 350 int i; |
351 | |
352 for (i=0; i < 2; i++) { | |
353 | |
354 /* get motion code */ | |
2017 | 355 diff = get_vlc2(bitbuf, svq1_motion_component.table, 7, 2); |
356 if(diff<0) | |
357 return -1; | |
358 else if(diff){ | |
359 if(get_bits1(bitbuf)) diff= -diff; | |
360 } | |
521 | 361 |
362 /* add median of motion vector predictors and clip result */ | |
363 if (i == 1) | |
2017 | 364 mv->y = ((diff + mid_pred(pmv[0]->y, pmv[1]->y, pmv[2]->y)) << 26) >> 26; |
521 | 365 else |
2017 | 366 mv->x = ((diff + mid_pred(pmv[0]->x, pmv[1]->x, pmv[2]->x)) << 26) >> 26; |
521 | 367 } |
368 | |
369 return 0; | |
370 } | |
371 | |
528 | 372 static void svq1_skip_block (uint8_t *current, uint8_t *previous, int pitch, int x, int y) { |
521 | 373 uint8_t *src; |
374 uint8_t *dst; | |
375 int i; | |
376 | |
377 src = &previous[x + y*pitch]; | |
378 dst = current; | |
379 | |
380 for (i=0; i < 16; i++) { | |
381 memcpy (dst, src, 16); | |
382 src += pitch; | |
383 dst += pitch; | |
384 } | |
385 } | |
386 | |
1283
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
387 static int svq1_motion_inter_block (MpegEncContext *s, GetBitContext *bitbuf, |
521 | 388 uint8_t *current, uint8_t *previous, int pitch, |
389 svq1_pmv_t *motion, int x, int y) { | |
390 uint8_t *src; | |
391 uint8_t *dst; | |
392 svq1_pmv_t mv; | |
393 svq1_pmv_t *pmv[3]; | |
394 int result; | |
395 | |
396 /* predict and decode motion vector */ | |
397 pmv[0] = &motion[0]; | |
398 if (y == 0) { | |
528 | 399 pmv[1] = |
521 | 400 pmv[2] = pmv[0]; |
401 } | |
528 | 402 else { |
403 pmv[1] = &motion[(x / 8) + 2]; | |
404 pmv[2] = &motion[(x / 8) + 4]; | |
405 } | |
521 | 406 |
528 | 407 result = svq1_decode_motion_vector (bitbuf, &mv, pmv); |
521 | 408 |
409 if (result != 0) | |
410 return result; | |
411 | |
528 | 412 motion[0].x = |
413 motion[(x / 8) + 2].x = | |
521 | 414 motion[(x / 8) + 3].x = mv.x; |
528 | 415 motion[0].y = |
416 motion[(x / 8) + 2].y = | |
521 | 417 motion[(x / 8) + 3].y = mv.y; |
1049
6fadc19937b9
cliping MVs, i dunno if its correct but it looks better then without it
michaelni
parents:
1025
diff
changeset
|
418 |
6fadc19937b9
cliping MVs, i dunno if its correct but it looks better then without it
michaelni
parents:
1025
diff
changeset
|
419 if(y + (mv.y >> 1)<0) |
6fadc19937b9
cliping MVs, i dunno if its correct but it looks better then without it
michaelni
parents:
1025
diff
changeset
|
420 mv.y= 0; |
6fadc19937b9
cliping MVs, i dunno if its correct but it looks better then without it
michaelni
parents:
1025
diff
changeset
|
421 if(x + (mv.x >> 1)<0) |
6fadc19937b9
cliping MVs, i dunno if its correct but it looks better then without it
michaelni
parents:
1025
diff
changeset
|
422 mv.x= 0; |
521 | 423 |
1049
6fadc19937b9
cliping MVs, i dunno if its correct but it looks better then without it
michaelni
parents:
1025
diff
changeset
|
424 #if 0 |
6fadc19937b9
cliping MVs, i dunno if its correct but it looks better then without it
michaelni
parents:
1025
diff
changeset
|
425 int w= (s->width+15)&~15; |
6fadc19937b9
cliping MVs, i dunno if its correct but it looks better then without it
michaelni
parents:
1025
diff
changeset
|
426 int h= (s->height+15)&~15; |
6fadc19937b9
cliping MVs, i dunno if its correct but it looks better then without it
michaelni
parents:
1025
diff
changeset
|
427 if(x + (mv.x >> 1)<0 || y + (mv.y >> 1)<0 || x + (mv.x >> 1) + 16 > w || y + (mv.y >> 1) + 16> h) |
2005 | 428 av_log(s->avctx, AV_LOG_INFO, "%d %d %d %d\n", x, y, x + (mv.x >> 1), y + (mv.y >> 1)); |
1049
6fadc19937b9
cliping MVs, i dunno if its correct but it looks better then without it
michaelni
parents:
1025
diff
changeset
|
429 #endif |
6fadc19937b9
cliping MVs, i dunno if its correct but it looks better then without it
michaelni
parents:
1025
diff
changeset
|
430 |
521 | 431 src = &previous[(x + (mv.x >> 1)) + (y + (mv.y >> 1))*pitch]; |
432 dst = current; | |
433 | |
853
eacc2dd8fd9d
* using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents:
771
diff
changeset
|
434 s->dsp.put_pixels_tab[0][((mv.y & 1) << 1) | (mv.x & 1)](dst,src,pitch,16); |
521 | 435 |
436 return 0; | |
437 } | |
438 | |
1283
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
439 static int svq1_motion_inter_4v_block (MpegEncContext *s, GetBitContext *bitbuf, |
521 | 440 uint8_t *current, uint8_t *previous, int pitch, |
441 svq1_pmv_t *motion,int x, int y) { | |
442 uint8_t *src; | |
443 uint8_t *dst; | |
444 svq1_pmv_t mv; | |
445 svq1_pmv_t *pmv[4]; | |
446 int i, result; | |
447 | |
448 /* predict and decode motion vector (0) */ | |
449 pmv[0] = &motion[0]; | |
450 if (y == 0) { | |
528 | 451 pmv[1] = |
521 | 452 pmv[2] = pmv[0]; |
453 } | |
528 | 454 else { |
455 pmv[1] = &motion[(x / 8) + 2]; | |
456 pmv[2] = &motion[(x / 8) + 4]; | |
457 } | |
521 | 458 |
528 | 459 result = svq1_decode_motion_vector (bitbuf, &mv, pmv); |
521 | 460 |
461 if (result != 0) | |
462 return result; | |
463 | |
464 /* predict and decode motion vector (1) */ | |
465 pmv[0] = &mv; | |
466 if (y == 0) { | |
528 | 467 pmv[1] = |
521 | 468 pmv[2] = pmv[0]; |
469 } | |
528 | 470 else { |
471 pmv[1] = &motion[(x / 8) + 3]; | |
472 } | |
473 result = svq1_decode_motion_vector (bitbuf, &motion[0], pmv); | |
521 | 474 |
475 if (result != 0) | |
476 return result; | |
477 | |
478 /* predict and decode motion vector (2) */ | |
479 pmv[1] = &motion[0]; | |
480 pmv[2] = &motion[(x / 8) + 1]; | |
481 | |
528 | 482 result = svq1_decode_motion_vector (bitbuf, &motion[(x / 8) + 2], pmv); |
521 | 483 |
484 if (result != 0) | |
485 return result; | |
486 | |
487 /* predict and decode motion vector (3) */ | |
488 pmv[2] = &motion[(x / 8) + 2]; | |
489 pmv[3] = &motion[(x / 8) + 3]; | |
490 | |
528 | 491 result = svq1_decode_motion_vector (bitbuf, pmv[3], pmv); |
521 | 492 |
493 if (result != 0) | |
494 return result; | |
495 | |
496 /* form predictions */ | |
497 for (i=0; i < 4; i++) { | |
1049
6fadc19937b9
cliping MVs, i dunno if its correct but it looks better then without it
michaelni
parents:
1025
diff
changeset
|
498 int mvx= pmv[i]->x + (i&1)*16; |
6fadc19937b9
cliping MVs, i dunno if its correct but it looks better then without it
michaelni
parents:
1025
diff
changeset
|
499 int mvy= pmv[i]->y + (i>>1)*16; |
6fadc19937b9
cliping MVs, i dunno if its correct but it looks better then without it
michaelni
parents:
1025
diff
changeset
|
500 |
6fadc19937b9
cliping MVs, i dunno if its correct but it looks better then without it
michaelni
parents:
1025
diff
changeset
|
501 ///XXX /FIXME cliping or padding? |
6fadc19937b9
cliping MVs, i dunno if its correct but it looks better then without it
michaelni
parents:
1025
diff
changeset
|
502 if(y + (mvy >> 1)<0) |
6fadc19937b9
cliping MVs, i dunno if its correct but it looks better then without it
michaelni
parents:
1025
diff
changeset
|
503 mvy= 0; |
6fadc19937b9
cliping MVs, i dunno if its correct but it looks better then without it
michaelni
parents:
1025
diff
changeset
|
504 if(x + (mvx >> 1)<0) |
6fadc19937b9
cliping MVs, i dunno if its correct but it looks better then without it
michaelni
parents:
1025
diff
changeset
|
505 mvx= 0; |
6fadc19937b9
cliping MVs, i dunno if its correct but it looks better then without it
michaelni
parents:
1025
diff
changeset
|
506 |
6fadc19937b9
cliping MVs, i dunno if its correct but it looks better then without it
michaelni
parents:
1025
diff
changeset
|
507 #if 0 |
6fadc19937b9
cliping MVs, i dunno if its correct but it looks better then without it
michaelni
parents:
1025
diff
changeset
|
508 int w= (s->width+15)&~15; |
6fadc19937b9
cliping MVs, i dunno if its correct but it looks better then without it
michaelni
parents:
1025
diff
changeset
|
509 int h= (s->height+15)&~15; |
6fadc19937b9
cliping MVs, i dunno if its correct but it looks better then without it
michaelni
parents:
1025
diff
changeset
|
510 if(x + (mvx >> 1)<0 || y + (mvy >> 1)<0 || x + (mvx >> 1) + 8 > w || y + (mvy >> 1) + 8> h) |
2005 | 511 av_log(s->avctx, AV_LOG_INFO, "%d %d %d %d\n", x, y, x + (mvx >> 1), y + (mvy >> 1)); |
1049
6fadc19937b9
cliping MVs, i dunno if its correct but it looks better then without it
michaelni
parents:
1025
diff
changeset
|
512 #endif |
6fadc19937b9
cliping MVs, i dunno if its correct but it looks better then without it
michaelni
parents:
1025
diff
changeset
|
513 src = &previous[(x + (mvx >> 1)) + (y + (mvy >> 1))*pitch]; |
521 | 514 dst = current; |
1049
6fadc19937b9
cliping MVs, i dunno if its correct but it looks better then without it
michaelni
parents:
1025
diff
changeset
|
515 |
6fadc19937b9
cliping MVs, i dunno if its correct but it looks better then without it
michaelni
parents:
1025
diff
changeset
|
516 s->dsp.put_pixels_tab[1][((mvy & 1) << 1) | (mvx & 1)](dst,src,pitch,8); |
521 | 517 |
518 /* select next block */ | |
519 if (i & 1) { | |
520 current += 8*(pitch - 1); | |
521 } else { | |
522 current += 8; | |
523 } | |
524 } | |
525 | |
526 return 0; | |
527 } | |
528 | |
1283
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
529 static int svq1_decode_delta_block (MpegEncContext *s, GetBitContext *bitbuf, |
521 | 530 uint8_t *current, uint8_t *previous, int pitch, |
531 svq1_pmv_t *motion, int x, int y) { | |
532 uint32_t block_type; | |
533 int result = 0; | |
534 | |
535 /* get block type */ | |
1283
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
536 block_type = get_vlc2(bitbuf, svq1_block_type.table, 2, 2); |
521 | 537 |
538 /* reset motion vectors */ | |
539 if (block_type == SVQ1_BLOCK_SKIP || block_type == SVQ1_BLOCK_INTRA) { | |
528 | 540 motion[0].x = |
541 motion[0].y = | |
542 motion[(x / 8) + 2].x = | |
543 motion[(x / 8) + 2].y = | |
544 motion[(x / 8) + 3].x = | |
521 | 545 motion[(x / 8) + 3].y = 0; |
546 } | |
547 | |
548 switch (block_type) { | |
549 case SVQ1_BLOCK_SKIP: | |
528 | 550 svq1_skip_block (current, previous, pitch, x, y); |
521 | 551 break; |
552 | |
553 case SVQ1_BLOCK_INTER: | |
853
eacc2dd8fd9d
* using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents:
771
diff
changeset
|
554 result = svq1_motion_inter_block (s, bitbuf, current, previous, pitch, motion, x, y); |
521 | 555 |
556 if (result != 0) | |
557 { | |
558 #ifdef DEBUG_SVQ1 | |
2005 | 559 av_log(s->avctx, AV_LOG_INFO, "Error in svq1_motion_inter_block %i\n",result); |
521 | 560 #endif |
561 break; | |
562 } | |
528 | 563 result = svq1_decode_block_non_intra (bitbuf, current, pitch); |
521 | 564 break; |
565 | |
566 case SVQ1_BLOCK_INTER_4V: | |
853
eacc2dd8fd9d
* using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents:
771
diff
changeset
|
567 result = svq1_motion_inter_4v_block (s, bitbuf, current, previous, pitch, motion, x, y); |
521 | 568 |
569 if (result != 0) | |
570 { | |
571 #ifdef DEBUG_SVQ1 | |
2005 | 572 av_log(s->avctx, AV_LOG_INFO, "Error in svq1_motion_inter_4v_block %i\n",result); |
521 | 573 #endif |
574 break; | |
575 } | |
528 | 576 result = svq1_decode_block_non_intra (bitbuf, current, pitch); |
521 | 577 break; |
578 | |
579 case SVQ1_BLOCK_INTRA: | |
528 | 580 result = svq1_decode_block_intra (bitbuf, current, pitch); |
521 | 581 break; |
582 } | |
583 | |
584 return result; | |
585 } | |
586 | |
587 /* standard video sizes */ | |
528 | 588 static struct { int width; int height; } svq1_frame_size_table[8] = { |
521 | 589 { 160, 120 }, { 128, 96 }, { 176, 144 }, { 352, 288 }, |
590 { 704, 576 }, { 240, 180 }, { 320, 240 }, { -1, -1 } | |
591 }; | |
592 | |
1283
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
593 static uint16_t svq1_packet_checksum (uint8_t *data, int length, int value) { |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
594 int i; |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
595 |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
596 for (i=0; i < length; i++) { |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
597 value = checksum_table[data[i] ^ (value >> 8)] ^ ((value & 0xFF) << 8); |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
598 } |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
599 |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
600 return value; |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
601 } |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
602 |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
603 static uint16_t svq1_component_checksum (uint16_t *pixels, int pitch, |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
604 int width, int height, int value) { |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
605 int x, y; |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
606 |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
607 for (y=0; y < height; y++) { |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
608 for (x=0; x < width; x++) { |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
609 value = checksum_table[pixels[x] ^ (value >> 8)] ^ ((value & 0xFF) << 8); |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
610 } |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
611 |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
612 pixels += pitch; |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
613 } |
521 | 614 |
1283
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
615 return value; |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
616 } |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
617 |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
618 static void svq1_parse_string (GetBitContext *bitbuf, uint8_t *out) { |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
619 uint8_t seed; |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
620 int i; |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
621 |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
622 out[0] = get_bits (bitbuf, 8); |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
623 |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
624 seed = string_table[out[0]]; |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
625 |
1714
033eeef90b2b
off-by-1 error in the never-before-tested embedded string code
melanson
parents:
1598
diff
changeset
|
626 for (i=1; i <= out[0]; i++) { |
1283
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
627 out[i] = get_bits (bitbuf, 8) ^ seed; |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
628 seed = string_table[out[i] ^ seed]; |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
629 } |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
630 } |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
631 |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
632 static int svq1_decode_frame_header (GetBitContext *bitbuf,MpegEncContext *s) { |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
633 int frame_size_code; |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
634 int temporal_reference; |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
635 |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
636 temporal_reference = get_bits (bitbuf, 8); |
521 | 637 |
638 /* frame type */ | |
557 | 639 s->pict_type= get_bits (bitbuf, 2)+1; |
640 if(s->pict_type==4) | |
641 return -1; | |
1049
6fadc19937b9
cliping MVs, i dunno if its correct but it looks better then without it
michaelni
parents:
1025
diff
changeset
|
642 |
557 | 643 if (s->pict_type == I_TYPE) { |
521 | 644 |
645 /* unknown fields */ | |
646 if (s->f_code == 0x50 || s->f_code == 0x60) { | |
1283
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
647 int csum = get_bits (bitbuf, 16); |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
648 |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
649 csum = svq1_packet_checksum ((uint8_t *)bitbuf->buffer, bitbuf->size_in_bits>>3, csum); |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
650 |
2005 | 651 // av_log(s->avctx, AV_LOG_INFO, "%s checksum (%02x) for packet data\n", |
1283
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
652 // (csum == 0) ? "correct" : "incorrect", csum); |
521 | 653 } |
654 | |
655 if ((s->f_code ^ 0x10) >= 0x50) { | |
1283
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
656 char msg[256]; |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
657 |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
658 svq1_parse_string (bitbuf, (char *) msg); |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
659 |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1379
diff
changeset
|
660 av_log(s->avctx, AV_LOG_INFO, "embedded message: \"%s\"\n", (char *) msg); |
521 | 661 } |
662 | |
1379 | 663 skip_bits (bitbuf, 2); |
664 skip_bits (bitbuf, 2); | |
665 skip_bits1 (bitbuf); | |
521 | 666 |
667 /* load frame size */ | |
668 frame_size_code = get_bits (bitbuf, 3); | |
669 | |
670 if (frame_size_code == 7) { | |
671 /* load width, height (12 bits each) */ | |
672 s->width = get_bits (bitbuf, 12); | |
673 s->height = get_bits (bitbuf, 12); | |
674 | |
675 if (!s->width || !s->height) | |
676 return -1; | |
677 } else { | |
678 /* get width, height from table */ | |
528 | 679 s->width = svq1_frame_size_table[frame_size_code].width; |
680 s->height = svq1_frame_size_table[frame_size_code].height; | |
521 | 681 } |
682 } | |
683 | |
684 /* unknown fields */ | |
685 if (get_bits (bitbuf, 1) == 1) { | |
1379 | 686 skip_bits1 (bitbuf); /* use packet checksum if (1) */ |
687 skip_bits1 (bitbuf); /* component checksums after image data if (1) */ | |
521 | 688 |
689 if (get_bits (bitbuf, 2) != 0) | |
690 return -1; | |
691 } | |
692 | |
693 if (get_bits (bitbuf, 1) == 1) { | |
1379 | 694 skip_bits1 (bitbuf); |
695 skip_bits (bitbuf, 4); | |
696 skip_bits1 (bitbuf); | |
697 skip_bits (bitbuf, 2); | |
521 | 698 |
699 while (get_bits (bitbuf, 1) == 1) { | |
1379 | 700 skip_bits (bitbuf, 8); |
521 | 701 } |
702 } | |
703 | |
704 return 0; | |
705 } | |
706 | |
707 static int svq1_decode_frame(AVCodecContext *avctx, | |
708 void *data, int *data_size, | |
1064 | 709 uint8_t *buf, int buf_size) |
521 | 710 { |
711 MpegEncContext *s=avctx->priv_data; | |
712 uint8_t *current, *previous; | |
713 int result, i, x, y, width, height; | |
925 | 714 AVFrame *pict = data; |
521 | 715 |
716 /* initialize bit buffer */ | |
1025
1f9afd8b9131
GetBitContext.size is allways multiplied by 8 -> use size_in_bits to avoid useless *8 in a few inner loops
michaelni
parents:
982
diff
changeset
|
717 init_get_bits(&s->gb,buf,buf_size*8); |
521 | 718 |
719 /* decode frame header */ | |
720 s->f_code = get_bits (&s->gb, 22); | |
721 | |
722 if ((s->f_code & ~0x70) || !(s->f_code & 0x60)) | |
723 return -1; | |
724 | |
725 /* swap some header bytes (why?) */ | |
726 if (s->f_code != 0x20) { | |
727 uint32_t *src = (uint32_t *) (buf + 4); | |
728 | |
729 for (i=0; i < 4; i++) { | |
730 src[i] = ((src[i] << 16) | (src[i] >> 16)) ^ src[7 - i]; | |
731 } | |
732 } | |
733 | |
528 | 734 result = svq1_decode_frame_header (&s->gb, s); |
521 | 735 |
736 if (result != 0) | |
737 { | |
738 #ifdef DEBUG_SVQ1 | |
2005 | 739 av_log(s->avctx, AV_LOG_INFO, "Error in svq1_decode_frame_header %i\n",result); |
521 | 740 #endif |
741 return result; | |
742 } | |
561 | 743 |
982
a1866d06df1e
workaround dropable p frame after first frame bug
michaelni
parents:
925
diff
changeset
|
744 //FIXME this avoids some confusion for "B frames" without 2 references |
2005 | 745 //this should be removed after libavcodec can handle more flexible picture types & ordering |
1138 | 746 if(s->pict_type==B_TYPE && s->last_picture_ptr==NULL) return buf_size; |
982
a1866d06df1e
workaround dropable p frame after first frame bug
michaelni
parents:
925
diff
changeset
|
747 |
561 | 748 if(avctx->hurry_up && s->pict_type==B_TYPE) return buf_size; |
521 | 749 |
903 | 750 if(MPV_frame_start(s, avctx) < 0) |
751 return -1; | |
752 | |
521 | 753 /* decode y, u and v components */ |
754 for (i=0; i < 3; i++) { | |
557 | 755 int linesize; |
521 | 756 if (i == 0) { |
528 | 757 width = (s->width+15)&~15; |
758 height = (s->height+15)&~15; | |
557 | 759 linesize= s->linesize; |
521 | 760 } else { |
560 | 761 if(s->flags&CODEC_FLAG_GRAY) break; |
528 | 762 width = (s->width/4+15)&~15; |
763 height = (s->height/4+15)&~15; | |
557 | 764 linesize= s->uvlinesize; |
521 | 765 } |
766 | |
903 | 767 current = s->current_picture.data[i]; |
521 | 768 |
557 | 769 if(s->pict_type==B_TYPE){ |
903 | 770 previous = s->next_picture.data[i]; |
557 | 771 }else{ |
903 | 772 previous = s->last_picture.data[i]; |
557 | 773 } |
774 | |
775 if (s->pict_type == I_TYPE) { | |
521 | 776 /* keyframe */ |
777 for (y=0; y < height; y+=16) { | |
778 for (x=0; x < width; x+=16) { | |
557 | 779 result = svq1_decode_block_intra (&s->gb, ¤t[x], linesize); |
521 | 780 if (result != 0) |
781 { | |
2005 | 782 //#ifdef DEBUG_SVQ1 |
783 av_log(s->avctx, AV_LOG_INFO, "Error in svq1_decode_block %i (keyframe)\n",result); | |
784 //#endif | |
521 | 785 return result; |
786 } | |
787 } | |
557 | 788 current += 16*linesize; |
521 | 789 } |
790 } else { | |
557 | 791 svq1_pmv_t pmv[width/8+3]; |
521 | 792 /* delta frame */ |
557 | 793 memset (pmv, 0, ((width / 8) + 3) * sizeof(svq1_pmv_t)); |
521 | 794 |
795 for (y=0; y < height; y+=16) { | |
796 for (x=0; x < width; x+=16) { | |
853
eacc2dd8fd9d
* using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents:
771
diff
changeset
|
797 result = svq1_decode_delta_block (s, &s->gb, ¤t[x], previous, |
eacc2dd8fd9d
* using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents:
771
diff
changeset
|
798 linesize, pmv, x, y); |
521 | 799 if (result != 0) |
800 { | |
801 #ifdef DEBUG_SVQ1 | |
2005 | 802 av_log(s->avctx, AV_LOG_INFO, "Error in svq1_decode_delta_block %i\n",result); |
521 | 803 #endif |
804 return result; | |
805 } | |
806 } | |
807 | |
557 | 808 pmv[0].x = |
809 pmv[0].y = 0; | |
521 | 810 |
557 | 811 current += 16*linesize; |
521 | 812 } |
813 } | |
903 | 814 } |
815 | |
925 | 816 *pict = *(AVFrame*)&s->current_picture; |
528 | 817 |
557 | 818 |
903 | 819 MPV_frame_end(s); |
820 | |
925 | 821 *data_size=sizeof(AVFrame); |
561 | 822 return buf_size; |
521 | 823 } |
824 | |
825 static int svq1_decode_init(AVCodecContext *avctx) | |
826 { | |
827 MpegEncContext *s = avctx->priv_data; | |
1283
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
828 int i; |
579 | 829 |
1892 | 830 MPV_decode_defaults(s); |
831 | |
521 | 832 s->avctx = avctx; |
833 s->width = (avctx->width+3)&~3; | |
834 s->height = (avctx->height+3)&~3; | |
835 s->codec_id= avctx->codec->id; | |
557 | 836 avctx->pix_fmt = PIX_FMT_YUV410P; |
924 | 837 avctx->has_b_frames= 1; // not true, but DP frames and these behave like unidirectional b frames |
2005 | 838 s->flags= avctx->flags; |
521 | 839 if (MPV_common_init(s) < 0) return -1; |
1283
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
840 |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
841 init_vlc(&svq1_block_type, 2, 4, |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
842 &svq1_block_type_vlc[0][1], 2, 1, |
2370
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2268
diff
changeset
|
843 &svq1_block_type_vlc[0][0], 2, 1, 1); |
1283
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
844 |
2017 | 845 init_vlc(&svq1_motion_component, 7, 33, |
846 &mvtab[0][1], 2, 1, | |
2370
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2268
diff
changeset
|
847 &mvtab[0][0], 2, 1, 1); |
1283
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
848 |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
849 for (i = 0; i < 6; i++) { |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
850 init_vlc(&svq1_intra_multistage[i], 3, 8, |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
851 &svq1_intra_multistage_vlc[i][0][1], 2, 1, |
2370
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2268
diff
changeset
|
852 &svq1_intra_multistage_vlc[i][0][0], 2, 1, 1); |
1283
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
853 init_vlc(&svq1_inter_multistage[i], 3, 8, |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
854 &svq1_inter_multistage_vlc[i][0][1], 2, 1, |
2370
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2268
diff
changeset
|
855 &svq1_inter_multistage_vlc[i][0][0], 2, 1, 1); |
1283
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
856 } |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
857 |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
858 init_vlc(&svq1_intra_mean, 8, 256, |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
859 &svq1_intra_mean_vlc[0][1], 4, 2, |
2370
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2268
diff
changeset
|
860 &svq1_intra_mean_vlc[0][0], 4, 2, 1); |
1283
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
861 |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
862 init_vlc(&svq1_inter_mean, 9, 512, |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
863 &svq1_inter_mean_vlc[0][1], 4, 2, |
2370
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2268
diff
changeset
|
864 &svq1_inter_mean_vlc[0][0], 4, 2, 1); |
1283
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
865 |
521 | 866 return 0; |
867 } | |
868 | |
869 static int svq1_decode_end(AVCodecContext *avctx) | |
870 { | |
871 MpegEncContext *s = avctx->priv_data; | |
872 | |
873 MPV_common_end(s); | |
874 return 0; | |
875 } | |
876 | |
2005 | 877 static void svq1_write_header(SVQ1Context *s, int frame_type) |
878 { | |
2214 | 879 int i; |
880 | |
2005 | 881 /* frame code */ |
882 put_bits(&s->pb, 22, 0x20); | |
883 | |
884 /* temporal reference (sure hope this is a "don't care") */ | |
885 put_bits(&s->pb, 8, 0x00); | |
886 | |
887 /* frame type */ | |
888 put_bits(&s->pb, 2, frame_type - 1); | |
889 | |
890 if (frame_type == I_TYPE) { | |
891 | |
892 /* no checksum since frame code is 0x20 */ | |
893 | |
894 /* no embedded string either */ | |
895 | |
896 /* output 5 unknown bits (2 + 2 + 1) */ | |
897 put_bits(&s->pb, 5, 0); | |
898 | |
2214 | 899 for (i = 0; i < 7; i++) |
900 { | |
901 if ((svq1_frame_size_table[i].width == s->frame_width) && | |
902 (svq1_frame_size_table[i].height == s->frame_height)) | |
903 { | |
904 put_bits(&s->pb, 3, i); | |
905 break; | |
906 } | |
907 } | |
908 | |
909 if (i == 7) | |
910 { | |
911 put_bits(&s->pb, 3, 7); | |
912 put_bits(&s->pb, 12, s->frame_width); | |
913 put_bits(&s->pb, 12, s->frame_height); | |
914 } | |
2005 | 915 } |
916 | |
917 /* no checksum or extra data (next 2 bits get 0) */ | |
918 put_bits(&s->pb, 2, 0); | |
919 } | |
920 | |
921 | |
922 #define QUALITY_THRESHOLD 100 | |
923 #define THRESHOLD_MULTIPLIER 0.6 | |
924 | |
2069
a8100a516b0a
gcc bug workaround by (Jonathan Gray <khalek at linuxgamers dot net>)
michael
parents:
2028
diff
changeset
|
925 #if defined(HAVE_ALTIVEC) |
a8100a516b0a
gcc bug workaround by (Jonathan Gray <khalek at linuxgamers dot net>)
michael
parents:
2028
diff
changeset
|
926 #undef vector |
a8100a516b0a
gcc bug workaround by (Jonathan Gray <khalek at linuxgamers dot net>)
michael
parents:
2028
diff
changeset
|
927 #endif |
2005 | 928 |
2012
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
929 static int encode_block(SVQ1Context *s, uint8_t *src, uint8_t *ref, uint8_t *decoded, int stride, int level, int threshold, int lambda, int intra){ |
2007 | 930 int count, y, x, i, j, split, best_mean, best_score, best_count; |
931 int best_vector[6]; | |
932 int block_sum[7]= {0, 0, 0, 0, 0, 0}; | |
933 int w= 2<<((level+2)>>1); | |
934 int h= 2<<((level+1)>>1); | |
935 int size=w*h; | |
936 int16_t block[7][256]; | |
2011
8c7e7c332b86
using pointers so the code could eventually be used for P frames
michael
parents:
2010
diff
changeset
|
937 const int8_t *codebook_sum, *codebook; |
8c7e7c332b86
using pointers so the code could eventually be used for P frames
michael
parents:
2010
diff
changeset
|
938 const uint16_t (*mean_vlc)[2]; |
8c7e7c332b86
using pointers so the code could eventually be used for P frames
michael
parents:
2010
diff
changeset
|
939 const uint8_t (*multistage_vlc)[2]; |
8c7e7c332b86
using pointers so the code could eventually be used for P frames
michael
parents:
2010
diff
changeset
|
940 |
2012
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
941 best_score=0; |
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
942 //FIXME optimize, this doenst need to be done multiple times |
2011
8c7e7c332b86
using pointers so the code could eventually be used for P frames
michael
parents:
2010
diff
changeset
|
943 if(intra){ |
8c7e7c332b86
using pointers so the code could eventually be used for P frames
michael
parents:
2010
diff
changeset
|
944 codebook_sum= svq1_intra_codebook_sum[level]; |
8c7e7c332b86
using pointers so the code could eventually be used for P frames
michael
parents:
2010
diff
changeset
|
945 codebook= svq1_intra_codebooks[level]; |
8c7e7c332b86
using pointers so the code could eventually be used for P frames
michael
parents:
2010
diff
changeset
|
946 mean_vlc= svq1_intra_mean_vlc; |
8c7e7c332b86
using pointers so the code could eventually be used for P frames
michael
parents:
2010
diff
changeset
|
947 multistage_vlc= svq1_intra_multistage_vlc[level]; |
2012
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
948 for(y=0; y<h; y++){ |
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
949 for(x=0; x<w; x++){ |
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
950 int v= src[x + y*stride]; |
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
951 block[0][x + w*y]= v; |
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
952 best_score += v*v; |
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
953 block_sum[0] += v; |
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
954 } |
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
955 } |
2011
8c7e7c332b86
using pointers so the code could eventually be used for P frames
michael
parents:
2010
diff
changeset
|
956 }else{ |
8c7e7c332b86
using pointers so the code could eventually be used for P frames
michael
parents:
2010
diff
changeset
|
957 codebook_sum= svq1_inter_codebook_sum[level]; |
8c7e7c332b86
using pointers so the code could eventually be used for P frames
michael
parents:
2010
diff
changeset
|
958 codebook= svq1_inter_codebooks[level]; |
2012
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
959 mean_vlc= svq1_inter_mean_vlc + 256; |
2011
8c7e7c332b86
using pointers so the code could eventually be used for P frames
michael
parents:
2010
diff
changeset
|
960 multistage_vlc= svq1_inter_multistage_vlc[level]; |
2012
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
961 for(y=0; y<h; y++){ |
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
962 for(x=0; x<w; x++){ |
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
963 int v= src[x + y*stride] - ref[x + y*stride]; |
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
964 block[0][x + w*y]= v; |
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
965 best_score += v*v; |
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
966 block_sum[0] += v; |
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
967 } |
2007 | 968 } |
969 } | |
970 | |
971 best_count=0; | |
972 best_score -= ((block_sum[0]*block_sum[0])>>(level+3)); | |
973 best_mean= (block_sum[0] + (size>>1)) >> (level+3); | |
974 | |
975 if(level<4){ | |
976 for(count=1; count<7; count++){ | |
977 int best_vector_score= INT_MAX; | |
2012
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
978 int best_vector_sum=-999, best_vector_mean=-999; |
2007 | 979 const int stage= count-1; |
2011
8c7e7c332b86
using pointers so the code could eventually be used for P frames
michael
parents:
2010
diff
changeset
|
980 const int8_t *vector; |
2007 | 981 |
982 for(i=0; i<16; i++){ | |
2011
8c7e7c332b86
using pointers so the code could eventually be used for P frames
michael
parents:
2010
diff
changeset
|
983 int sum= codebook_sum[stage*16 + i]; |
2007 | 984 int sqr=0; |
985 int diff, mean, score; | |
986 | |
2011
8c7e7c332b86
using pointers so the code could eventually be used for P frames
michael
parents:
2010
diff
changeset
|
987 vector = codebook + stage*size*16 + i*size; |
2007 | 988 |
989 for(j=0; j<size; j++){ | |
990 int v= vector[j]; | |
991 sqr += (v - block[stage][j])*(v - block[stage][j]); | |
992 } | |
993 diff= block_sum[stage] - sum; | |
994 mean= (diff + (size>>1)) >> (level+3); | |
2012
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
995 assert(mean >-300 && mean<300); |
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
996 if(intra) mean= clip(mean, 0, 255); |
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
997 else mean= clip(mean, -256, 255); |
2007 | 998 score= sqr - ((diff*(int64_t)diff)>>(level+3)); //FIXME 64bit slooow |
999 if(score < best_vector_score){ | |
1000 best_vector_score= score; | |
1001 best_vector[stage]= i; | |
1002 best_vector_sum= sum; | |
1003 best_vector_mean= mean; | |
1004 } | |
1005 } | |
2012
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
1006 assert(best_vector_mean != -999); |
2011
8c7e7c332b86
using pointers so the code could eventually be used for P frames
michael
parents:
2010
diff
changeset
|
1007 vector= codebook + stage*size*16 + best_vector[stage]*size; |
2007 | 1008 for(j=0; j<size; j++){ |
1009 block[stage+1][j] = block[stage][j] - vector[j]; | |
1010 } | |
1011 block_sum[stage+1]= block_sum[stage] - best_vector_sum; | |
1012 best_vector_score += | |
1013 lambda*(+ 1 + 4*count | |
2011
8c7e7c332b86
using pointers so the code could eventually be used for P frames
michael
parents:
2010
diff
changeset
|
1014 + multistage_vlc[1+count][1] |
8c7e7c332b86
using pointers so the code could eventually be used for P frames
michael
parents:
2010
diff
changeset
|
1015 + mean_vlc[best_vector_mean][1]); |
2007 | 1016 |
1017 if(best_vector_score < best_score){ | |
1018 best_score= best_vector_score; | |
1019 best_count= count; | |
1020 best_mean= best_vector_mean; | |
1021 } | |
1022 } | |
1023 } | |
1024 | |
1025 split=0; | |
1026 if(best_score > threshold && level){ | |
1027 int score=0; | |
1028 int offset= (level&1) ? stride*h/2 : w/2; | |
1029 PutBitContext backup[6]; | |
1030 | |
1031 for(i=level-1; i>=0; i--){ | |
1032 backup[i]= s->reorder_pb[i]; | |
1033 } | |
2012
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
1034 score += encode_block(s, src , ref , decoded , stride, level-1, threshold>>1, lambda, intra); |
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
1035 score += encode_block(s, src + offset, ref + offset, decoded + offset, stride, level-1, threshold>>1, lambda, intra); |
2007 | 1036 score += lambda; |
1037 | |
1038 if(score < best_score){ | |
1039 best_score= score; | |
1040 split=1; | |
1041 }else{ | |
1042 for(i=level-1; i>=0; i--){ | |
1043 s->reorder_pb[i]= backup[i]; | |
1044 } | |
1045 } | |
1046 } | |
1047 if (level > 0) | |
1048 put_bits(&s->reorder_pb[level], 1, split); | |
1049 | |
1050 if(!split){ | |
2012
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
1051 assert((best_mean >= 0 && best_mean<256) || !intra); |
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
1052 assert(best_mean >= -256 && best_mean<256); |
2007 | 1053 assert(best_count >=0 && best_count<7); |
1054 assert(level<4 || best_count==0); | |
1055 | |
1056 /* output the encoding */ | |
1057 put_bits(&s->reorder_pb[level], | |
2011
8c7e7c332b86
using pointers so the code could eventually be used for P frames
michael
parents:
2010
diff
changeset
|
1058 multistage_vlc[1 + best_count][1], |
8c7e7c332b86
using pointers so the code could eventually be used for P frames
michael
parents:
2010
diff
changeset
|
1059 multistage_vlc[1 + best_count][0]); |
8c7e7c332b86
using pointers so the code could eventually be used for P frames
michael
parents:
2010
diff
changeset
|
1060 put_bits(&s->reorder_pb[level], mean_vlc[best_mean][1], |
8c7e7c332b86
using pointers so the code could eventually be used for P frames
michael
parents:
2010
diff
changeset
|
1061 mean_vlc[best_mean][0]); |
2007 | 1062 |
1063 for (i = 0; i < best_count; i++){ | |
1064 assert(best_vector[i]>=0 && best_vector[i]<16); | |
1065 put_bits(&s->reorder_pb[level], 4, best_vector[i]); | |
1066 } | |
2012
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
1067 |
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
1068 for(y=0; y<h; y++){ |
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
1069 for(x=0; x<w; x++){ |
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
1070 decoded[x + y*stride]= src[x + y*stride] - block[best_count][x + w*y] + best_mean; |
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
1071 } |
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
1072 } |
2007 | 1073 } |
1074 | |
1075 return best_score; | |
1076 } | |
1077 | |
2077 | 1078 #ifdef CONFIG_ENCODERS |
1079 | |
2422 | 1080 static int svq1_encode_plane(SVQ1Context *s, int plane, unsigned char *src_plane, unsigned char *ref_plane, unsigned char *decoded_plane, |
2012
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
1081 int width, int height, int src_stride, int stride) |
2005 | 1082 { |
1083 int x, y; | |
2021 | 1084 int i; |
2005 | 1085 int block_width, block_height; |
1086 int level; | |
1087 int threshold[6]; | |
2012
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
1088 const int lambda= (s->picture.quality*s->picture.quality) >> (2*FF_LAMBDA_SHIFT); |
2005 | 1089 |
1090 /* figure out the acceptable level thresholds in advance */ | |
1091 threshold[5] = QUALITY_THRESHOLD; | |
1092 for (level = 4; level >= 0; level--) | |
1093 threshold[level] = threshold[level + 1] * THRESHOLD_MULTIPLIER; | |
1094 | |
1095 block_width = (width + 15) / 16; | |
1096 block_height = (height + 15) / 16; | |
1097 | |
2017 | 1098 if(s->picture.pict_type == P_TYPE){ |
1099 s->m.avctx= s->avctx; | |
1100 s->m.current_picture_ptr= &s->m.current_picture; | |
1101 s->m.last_picture_ptr = &s->m.last_picture; | |
1102 s->m.last_picture.data[0]= ref_plane; | |
1103 s->m.linesize= | |
1104 s->m.last_picture.linesize[0]= | |
1105 s->m.new_picture.linesize[0]= | |
1106 s->m.current_picture.linesize[0]= stride; | |
1107 s->m.width= width; | |
1108 s->m.height= height; | |
1109 s->m.mb_width= block_width; | |
1110 s->m.mb_height= block_height; | |
1111 s->m.mb_stride= s->m.mb_width+1; | |
1112 s->m.b8_stride= 2*s->m.mb_width+1; | |
1113 s->m.f_code=1; | |
1114 s->m.pict_type= s->picture.pict_type; | |
1115 s->m.qscale= s->picture.quality/FF_QP2LAMBDA; | |
1116 s->m.me_method= s->avctx->me_method; | |
1117 | |
1118 if(!s->motion_val8[plane]){ | |
2153 | 1119 s->motion_val8 [plane]= av_mallocz((s->m.b8_stride*block_height*2 + 2)*2*sizeof(int16_t)); |
1120 s->motion_val16[plane]= av_mallocz((s->m.mb_stride*(block_height + 2) + 1)*2*sizeof(int16_t)); | |
2017 | 1121 } |
2153 | 1122 |
2017 | 1123 s->m.mb_type= s->mb_type; |
1124 | |
1125 //dummies, to avoid segfaults | |
2021 | 1126 s->m.current_picture.mb_mean= (uint8_t *)s->dummy; |
1127 s->m.current_picture.mb_var= (uint16_t*)s->dummy; | |
1128 s->m.current_picture.mc_mb_var= (uint16_t*)s->dummy; | |
2017 | 1129 s->m.current_picture.mb_type= s->dummy; |
1130 | |
2153 | 1131 s->m.current_picture.motion_val[0]= s->motion_val8[plane] + 2; |
1132 s->m.p_mv_table= s->motion_val16[plane] + s->m.mb_stride + 1; | |
2017 | 1133 s->m.dsp= s->dsp; //move |
1134 ff_init_me(&s->m); | |
1135 | |
1136 s->m.me.dia_size= s->avctx->dia_size; | |
1137 s->m.first_slice_line=1; | |
1138 for (y = 0; y < block_height; y++) { | |
1139 uint8_t src[stride*16]; | |
1140 | |
1141 s->m.new_picture.data[0]= src - y*16*stride; //ugly | |
1142 s->m.mb_y= y; | |
1143 | |
1144 for(i=0; i<16 && i + 16*y<height; i++){ | |
1145 memcpy(&src[i*stride], &src_plane[(i+16*y)*src_stride], width); | |
1146 for(x=width; x<16*block_width; x++) | |
1147 src[i*stride+x]= src[i*stride+x-1]; | |
1148 } | |
1149 for(; i<16 && i + 16*y<16*block_height; i++) | |
1150 memcpy(&src[i*stride], &src[(i-1)*stride], 16*block_width); | |
1151 | |
1152 for (x = 0; x < block_width; x++) { | |
1153 s->m.mb_x= x; | |
1154 ff_init_block_index(&s->m); | |
1155 ff_update_block_index(&s->m); | |
1156 | |
1157 ff_estimate_p_frame_motion(&s->m, x, y); | |
1158 } | |
1159 s->m.first_slice_line=0; | |
1160 } | |
1161 | |
1162 ff_fix_long_p_mvs(&s->m); | |
1163 ff_fix_long_mvs(&s->m, NULL, 0, s->m.p_mv_table, s->m.f_code, CANDIDATE_MB_TYPE_INTER, 0); | |
1164 } | |
1165 | |
1166 s->m.first_slice_line=1; | |
2005 | 1167 for (y = 0; y < block_height; y++) { |
2012
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
1168 uint8_t src[stride*16]; |
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
1169 |
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
1170 for(i=0; i<16 && i + 16*y<height; i++){ |
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
1171 memcpy(&src[i*stride], &src_plane[(i+16*y)*src_stride], width); |
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
1172 for(x=width; x<16*block_width; x++) |
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
1173 src[i*stride+x]= src[i*stride+x-1]; |
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
1174 } |
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
1175 for(; i<16 && i + 16*y<16*block_height; i++) |
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
1176 memcpy(&src[i*stride], &src[(i-1)*stride], 16*block_width); |
2005 | 1177 |
2017 | 1178 s->m.mb_y= y; |
2005 | 1179 for (x = 0; x < block_width; x++) { |
2017 | 1180 uint8_t reorder_buffer[3][6][7*32]; |
1181 int count[3][6]; | |
2012
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
1182 int offset = y * 16 * stride + x * 16; |
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
1183 uint8_t *decoded= decoded_plane + offset; |
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
1184 uint8_t *ref= ref_plane + offset; |
2017 | 1185 int score[4]={0,0,0,0}, best; |
2012
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
1186 uint8_t temp[16*stride]; |
2422 | 1187 |
1188 if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < 3000){ //FIXME check size | |
1189 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n"); | |
1190 return -1; | |
1191 } | |
2005 | 1192 |
2017 | 1193 s->m.mb_x= x; |
1194 ff_init_block_index(&s->m); | |
1195 ff_update_block_index(&s->m); | |
2007 | 1196 |
2017 | 1197 if(s->picture.pict_type == I_TYPE || (s->m.mb_type[x + y*s->m.mb_stride]&CANDIDATE_MB_TYPE_INTRA)){ |
1198 for(i=0; i<6; i++){ | |
1199 init_put_bits(&s->reorder_pb[i], reorder_buffer[0][i], 7*32); | |
1200 } | |
1201 if(s->picture.pict_type == P_TYPE){ | |
1202 const uint8_t *vlc= svq1_block_type_vlc[SVQ1_BLOCK_INTRA]; | |
1203 put_bits(&s->reorder_pb[5], vlc[1], vlc[0]); | |
1204 score[0]= vlc[1]*lambda; | |
1205 } | |
1206 score[0]+= encode_block(s, src+16*x, NULL, temp, stride, 5, 64, lambda, 1); | |
1207 for(i=0; i<6; i++){ | |
1208 count[0][i]= put_bits_count(&s->reorder_pb[i]); | |
1209 flush_put_bits(&s->reorder_pb[i]); | |
1210 } | |
1211 }else | |
1212 score[0]= INT_MAX; | |
1213 | |
1214 best=0; | |
1215 | |
2012
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
1216 if(s->picture.pict_type == P_TYPE){ |
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
1217 const uint8_t *vlc= svq1_block_type_vlc[SVQ1_BLOCK_INTER]; |
2017 | 1218 int mx, my, pred_x, pred_y, dxy; |
1219 int16_t *motion_ptr; | |
1220 | |
1221 motion_ptr= h263_pred_motion(&s->m, 0, 0, &pred_x, &pred_y); | |
1222 if(s->m.mb_type[x + y*s->m.mb_stride]&CANDIDATE_MB_TYPE_INTER){ | |
1223 for(i=0; i<6; i++) | |
1224 init_put_bits(&s->reorder_pb[i], reorder_buffer[1][i], 7*32); | |
1225 | |
2012
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
1226 put_bits(&s->reorder_pb[5], vlc[1], vlc[0]); |
2017 | 1227 |
1228 s->m.pb= s->reorder_pb[5]; | |
1229 mx= motion_ptr[0]; | |
1230 my= motion_ptr[1]; | |
1231 assert(mx>=-32 && mx<=31); | |
1232 assert(my>=-32 && my<=31); | |
1233 assert(pred_x>=-32 && pred_x<=31); | |
1234 assert(pred_y>=-32 && pred_y<=31); | |
1235 ff_h263_encode_motion(&s->m, mx - pred_x, 1); | |
1236 ff_h263_encode_motion(&s->m, my - pred_y, 1); | |
1237 s->reorder_pb[5]= s->m.pb; | |
1238 score[1] += lambda*put_bits_count(&s->reorder_pb[5]); | |
1239 | |
1240 dxy= (mx&1) + 2*(my&1); | |
1241 | |
1242 s->dsp.put_pixels_tab[0][dxy](temp+16, ref + (mx>>1) + stride*(my>>1), stride, 16); | |
1243 | |
1244 score[1]+= encode_block(s, src+16*x, temp+16, decoded, stride, 5, 64, lambda, 0); | |
1245 best= score[1] <= score[0]; | |
2018 | 1246 |
1247 vlc= svq1_block_type_vlc[SVQ1_BLOCK_SKIP]; | |
1248 score[2]= s->dsp.sse[0](NULL, src+16*x, ref, stride, 16); | |
1249 score[2]+= vlc[1]*lambda; | |
1250 if(score[2] < score[best] && mx==0 && my==0){ | |
1251 best=2; | |
1252 s->dsp.put_pixels_tab[0][0](decoded, ref, stride, 16); | |
1253 for(i=0; i<6; i++){ | |
1254 count[2][i]=0; | |
1255 } | |
1256 put_bits(&s->pb, vlc[1], vlc[0]); | |
1257 } | |
2012
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
1258 } |
2018 | 1259 |
2012
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
1260 if(best==1){ |
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
1261 for(i=0; i<6; i++){ |
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
1262 count[1][i]= put_bits_count(&s->reorder_pb[i]); |
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
1263 flush_put_bits(&s->reorder_pb[i]); |
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
1264 } |
2017 | 1265 }else{ |
1266 motion_ptr[0 ] = motion_ptr[1 ]= | |
1267 motion_ptr[2 ] = motion_ptr[3 ]= | |
1268 motion_ptr[0+2*s->m.b8_stride] = motion_ptr[1+2*s->m.b8_stride]= | |
1269 motion_ptr[2+2*s->m.b8_stride] = motion_ptr[3+2*s->m.b8_stride]=0; | |
2012
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
1270 } |
2017 | 1271 } |
2012
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
1272 |
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
1273 s->rd_total += score[best]; |
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
1274 |
2007 | 1275 for(i=5; i>=0; i--){ |
2012
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
1276 ff_copy_bits(&s->pb, reorder_buffer[best][i], count[best][i]); |
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
1277 } |
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
1278 if(best==0){ |
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
1279 s->dsp.put_pixels_tab[0][0](decoded, temp, stride, 16); |
2007 | 1280 } |
2005 | 1281 } |
2017 | 1282 s->m.first_slice_line=0; |
2005 | 1283 } |
2422 | 1284 return 0; |
2005 | 1285 } |
1286 | |
1287 static int svq1_encode_init(AVCodecContext *avctx) | |
1288 { | |
1289 SVQ1Context * const s = avctx->priv_data; | |
1290 | |
1291 dsputil_init(&s->dsp, avctx); | |
1292 avctx->coded_frame= (AVFrame*)&s->picture; | |
1293 | |
1294 s->frame_width = avctx->width; | |
1295 s->frame_height = avctx->height; | |
1296 | |
1297 s->y_block_width = (s->frame_width + 15) / 16; | |
1298 s->y_block_height = (s->frame_height + 15) / 16; | |
1299 | |
1300 s->c_block_width = (s->frame_width / 4 + 15) / 16; | |
1301 s->c_block_height = (s->frame_height / 4 + 15) / 16; | |
1302 | |
2017 | 1303 s->avctx= avctx; |
2268 | 1304 s->m.avctx= avctx; |
2017 | 1305 s->m.me.scratchpad= av_mallocz((avctx->width+64)*2*16*2*sizeof(uint8_t)); |
1306 s->m.me.map = av_mallocz(ME_MAP_SIZE*sizeof(uint32_t)); | |
1307 s->m.me.score_map = av_mallocz(ME_MAP_SIZE*sizeof(uint32_t)); | |
1308 s->mb_type = av_mallocz((s->y_block_width+1)*s->y_block_height*sizeof(int16_t)); | |
1309 s->dummy = av_mallocz((s->y_block_width+1)*s->y_block_height*sizeof(int32_t)); | |
1310 h263_encode_init(&s->m); //mv_penalty | |
1311 | |
2005 | 1312 return 0; |
1313 } | |
1314 | |
1315 static int svq1_encode_frame(AVCodecContext *avctx, unsigned char *buf, | |
1316 int buf_size, void *data) | |
1317 { | |
1318 SVQ1Context * const s = avctx->priv_data; | |
1319 AVFrame *pict = data; | |
1320 AVFrame * const p= (AVFrame*)&s->picture; | |
2012
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
1321 AVFrame temp; |
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
1322 int i; |
2005 | 1323 |
2012
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
1324 if(avctx->pix_fmt != PIX_FMT_YUV410P){ |
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
1325 av_log(avctx, AV_LOG_ERROR, "unsupported pixel format\n"); |
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
1326 return -1; |
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
1327 } |
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
1328 |
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
1329 if(!s->current_picture.data[0]){ |
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
1330 avctx->get_buffer(avctx, &s->current_picture); |
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
1331 avctx->get_buffer(avctx, &s->last_picture); |
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
1332 } |
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
1333 |
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
1334 temp= s->current_picture; |
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
1335 s->current_picture= s->last_picture; |
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
1336 s->last_picture= temp; |
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
1337 |
2005 | 1338 init_put_bits(&s->pb, buf, buf_size); |
1339 | |
1340 *p = *pict; | |
2012
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
1341 p->pict_type = avctx->frame_number % avctx->gop_size ? P_TYPE : I_TYPE; |
2011
8c7e7c332b86
using pointers so the code could eventually be used for P frames
michael
parents:
2010
diff
changeset
|
1342 p->key_frame = p->pict_type == I_TYPE; |
2005 | 1343 |
1344 svq1_write_header(s, p->pict_type); | |
2012
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
1345 for(i=0; i<3; i++){ |
2422 | 1346 if(svq1_encode_plane(s, i, |
2012
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
1347 s->picture.data[i], s->last_picture.data[i], s->current_picture.data[i], |
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
1348 s->frame_width / (i?4:1), s->frame_height / (i?4:1), |
2422 | 1349 s->picture.linesize[i], s->current_picture.linesize[i]) < 0) |
1350 return -1; | |
2005 | 1351 } |
1352 | |
1353 // align_put_bits(&s->pb); | |
1354 while(put_bits_count(&s->pb) & 31) | |
1355 put_bits(&s->pb, 1, 0); | |
2008 | 1356 |
1357 flush_put_bits(&s->pb); | |
2005 | 1358 |
1359 return (put_bits_count(&s->pb) / 8); | |
1360 } | |
1361 | |
1362 static int svq1_encode_end(AVCodecContext *avctx) | |
1363 { | |
1364 SVQ1Context * const s = avctx->priv_data; | |
2017 | 1365 int i; |
2005 | 1366 |
2010 | 1367 av_log(avctx, AV_LOG_DEBUG, "RD: %f\n", s->rd_total/(double)(avctx->width*avctx->height*avctx->frame_number)); |
1368 | |
2017 | 1369 av_freep(&s->m.me.scratchpad); |
1370 av_freep(&s->m.me.map); | |
1371 av_freep(&s->m.me.score_map); | |
1372 av_freep(&s->mb_type); | |
1373 av_freep(&s->dummy); | |
1374 | |
1375 for(i=0; i<3; i++){ | |
1376 av_freep(&s->motion_val8[i]); | |
1377 av_freep(&s->motion_val16[i]); | |
1378 } | |
2005 | 1379 |
1380 return 0; | |
1381 } | |
1382 | |
2077 | 1383 #endif //CONFIG_ENCODERS |
1384 | |
521 | 1385 AVCodec svq1_decoder = { |
1386 "svq1", | |
1387 CODEC_TYPE_VIDEO, | |
1388 CODEC_ID_SVQ1, | |
1389 sizeof(MpegEncContext), | |
1390 svq1_decode_init, | |
1391 NULL, | |
1392 svq1_decode_end, | |
557 | 1393 svq1_decode_frame, |
1394 CODEC_CAP_DR1, | |
1368 | 1395 .flush= ff_mpeg_flush, |
2020 | 1396 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV410P, -1}, |
521 | 1397 }; |
2005 | 1398 |
1399 #ifdef CONFIG_ENCODERS | |
1400 | |
1401 AVCodec svq1_encoder = { | |
1402 "svq1", | |
1403 CODEC_TYPE_VIDEO, | |
1404 CODEC_ID_SVQ1, | |
1405 sizeof(SVQ1Context), | |
1406 svq1_encode_init, | |
1407 svq1_encode_frame, | |
1408 svq1_encode_end, | |
2020 | 1409 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV410P, -1}, |
2005 | 1410 }; |
1411 | |
1412 #endif //CONFIG_ENCODERS |