Mercurial > libavcodec.hg
annotate svq1.c @ 3604:dad0296d4522 libavcodec
replace MULL with asm too, no significnat speedup but its probably better to not take any chances, some versions of gcc will almost certainly mess it up too if they can
author | michael |
---|---|
date | Tue, 22 Aug 2006 12:07:02 +0000 |
parents | 0b546eab515d |
children | 1843a85123b7 |
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 /* |
2967 | 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 |
2967 | 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 |
3036
0b546eab515d
Update licensing information: The FSF changed postal address.
diego
parents:
2979
diff
changeset
|
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
536
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 |
2979 | 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 | |
521 | 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; | |
2967 | 74 |
2007 | 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; | |
2967 | 87 |
2017 | 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 { | |
2979 | 98 int x; |
99 int y; | |
521 | 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) {\ | |
2979 | 179 m = n;\ |
180 if (--level == 0)\ | |
181 break;\ | |
528 | 182 }\ |
183 /* divide block if next bit set */\ | |
184 if (get_bits (bitbuf, 1) == 0)\ | |
2979 | 185 break;\ |
528 | 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()\ |
2979 | 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 }\ | |
528 | 198 \ |
2979 | 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 }\ | |
528 | 206 \ |
2979 | 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 } | |
528 | 213 |
214 #define SVQ1_DO_CODEBOOK_INTRA()\ | |
215 for (y=0; y < height; y++) {\ | |
2979 | 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);\ | |
528 | 224 } |
225 | |
226 #define SVQ1_DO_CODEBOOK_NONINTRA()\ | |
227 for (y=0; y < height; y++) {\ | |
2979 | 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);\ | |
528 | 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++) {\ | |
2979 | 245 entries[j] = (((bit_cache >> (4*(stages - j - 1))) & 0xF) + 16*j) << (level + 1);\ |
528 | 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; |
2979 | 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) { | |
2979 | 277 for (y=0; y < height; y++) { |
278 memset (&dst[y*(pitch / 4)], 0, width); | |
279 } | |
280 continue; /* skip vector */ | |
521 | 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 |
2979 | 287 return -1; /* invalid vector */ |
521 | 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++) { |
2979 | 294 memset (&dst[y*(pitch / 4)], mean, width); |
521 | 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; |
2979 | 310 int entries[6]; |
311 int i, j, m, n; | |
312 int mean, stages; | |
313 int x, y, width, height, level; | |
528 | 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 |
2979 | 331 if (stages == -1) continue; /* skip vector */ |
528 | 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 |
2979 | 337 return -1; /* invalid vector */ |
528 | 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) { |
2979 | 349 int diff; |
350 int i; | |
521 | 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); |
2967 | 356 if(diff<0) |
2017 | 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; | |
2979 | 375 int i; |
521 | 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, |
2979 | 388 uint8_t *current, uint8_t *previous, int pitch, |
389 svq1_pmv_t *motion, int x, int y) { | |
521 | 390 uint8_t *src; |
391 uint8_t *dst; | |
392 svq1_pmv_t mv; | |
393 svq1_pmv_t *pmv[3]; | |
2979 | 394 int result; |
521 | 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 | |
2979 | 412 motion[0].x = |
413 motion[(x / 8) + 2].x = | |
414 motion[(x / 8) + 3].x = mv.x; | |
415 motion[0].y = | |
416 motion[(x / 8) + 2].y = | |
417 motion[(x / 8) + 3].y = mv.y; | |
2967 | 418 |
1049
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 |
2967 | 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, |
2979 | 440 uint8_t *current, uint8_t *previous, int pitch, |
441 svq1_pmv_t *motion,int x, int y) { | |
521 | 442 uint8_t *src; |
443 uint8_t *dst; | |
444 svq1_pmv_t mv; | |
445 svq1_pmv_t *pmv[4]; | |
2979 | 446 int i, result; |
521 | 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; |
2967 | 500 |
1049
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; |
2967 | 515 |
1049
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, |
2979 | 530 uint8_t *current, uint8_t *previous, int pitch, |
531 svq1_pmv_t *motion, int x, int y) { | |
521 | 532 uint32_t block_type; |
2979 | 533 int result = 0; |
521 | 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) { | |
2979 | 540 motion[0].x = |
541 motion[0].y = | |
528 | 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 |
2522
e25782262d7d
kill warnings patch by (M«©ns Rullg«©rd <mru inprovide com>)
michael
parents:
2453
diff
changeset
|
603 #if 0 /* unused, remove? */ |
1283
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
604 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
|
605 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
|
606 int x, y; |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
607 |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
608 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
|
609 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
|
610 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
|
611 } |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
612 |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
613 pixels += pitch; |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
614 } |
521 | 615 |
1283
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
616 return value; |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
617 } |
2522
e25782262d7d
kill warnings patch by (M«©ns Rullg«©rd <mru inprovide com>)
michael
parents:
2453
diff
changeset
|
618 #endif |
1283
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
619 |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
620 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
|
621 uint8_t seed; |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
622 int i; |
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 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
|
625 |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
626 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
|
627 |
1714
033eeef90b2b
off-by-1 error in the never-before-tested embedded string code
melanson
parents:
1598
diff
changeset
|
628 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
|
629 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
|
630 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
|
631 } |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
632 } |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
633 |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
634 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
|
635 int frame_size_code; |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
636 int temporal_reference; |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
637 |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
638 temporal_reference = get_bits (bitbuf, 8); |
521 | 639 |
640 /* frame type */ | |
557 | 641 s->pict_type= get_bits (bitbuf, 2)+1; |
2967 | 642 if(s->pict_type==4) |
557 | 643 return -1; |
2967 | 644 |
557 | 645 if (s->pict_type == I_TYPE) { |
521 | 646 |
647 /* unknown fields */ | |
648 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
|
649 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
|
650 |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
651 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
|
652 |
2005 | 653 // 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
|
654 // (csum == 0) ? "correct" : "incorrect", csum); |
521 | 655 } |
656 | |
657 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
|
658 char msg[256]; |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
659 |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
660 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
|
661 |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1379
diff
changeset
|
662 av_log(s->avctx, AV_LOG_INFO, "embedded message: \"%s\"\n", (char *) msg); |
521 | 663 } |
664 | |
1379 | 665 skip_bits (bitbuf, 2); |
666 skip_bits (bitbuf, 2); | |
667 skip_bits1 (bitbuf); | |
521 | 668 |
669 /* load frame size */ | |
670 frame_size_code = get_bits (bitbuf, 3); | |
671 | |
672 if (frame_size_code == 7) { | |
673 /* load width, height (12 bits each) */ | |
674 s->width = get_bits (bitbuf, 12); | |
675 s->height = get_bits (bitbuf, 12); | |
676 | |
677 if (!s->width || !s->height) | |
678 return -1; | |
679 } else { | |
680 /* get width, height from table */ | |
528 | 681 s->width = svq1_frame_size_table[frame_size_code].width; |
682 s->height = svq1_frame_size_table[frame_size_code].height; | |
521 | 683 } |
684 } | |
685 | |
686 /* unknown fields */ | |
687 if (get_bits (bitbuf, 1) == 1) { | |
1379 | 688 skip_bits1 (bitbuf); /* use packet checksum if (1) */ |
689 skip_bits1 (bitbuf); /* component checksums after image data if (1) */ | |
521 | 690 |
691 if (get_bits (bitbuf, 2) != 0) | |
692 return -1; | |
693 } | |
694 | |
695 if (get_bits (bitbuf, 1) == 1) { | |
1379 | 696 skip_bits1 (bitbuf); |
697 skip_bits (bitbuf, 4); | |
698 skip_bits1 (bitbuf); | |
699 skip_bits (bitbuf, 2); | |
521 | 700 |
701 while (get_bits (bitbuf, 1) == 1) { | |
1379 | 702 skip_bits (bitbuf, 8); |
521 | 703 } |
704 } | |
2967 | 705 |
521 | 706 return 0; |
707 } | |
708 | |
2967 | 709 static int svq1_decode_frame(AVCodecContext *avctx, |
521 | 710 void *data, int *data_size, |
1064 | 711 uint8_t *buf, int buf_size) |
521 | 712 { |
713 MpegEncContext *s=avctx->priv_data; | |
2979 | 714 uint8_t *current, *previous; |
715 int result, i, x, y, width, height; | |
2967 | 716 AVFrame *pict = data; |
521 | 717 |
718 /* 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
|
719 init_get_bits(&s->gb,buf,buf_size*8); |
521 | 720 |
721 /* decode frame header */ | |
722 s->f_code = get_bits (&s->gb, 22); | |
723 | |
724 if ((s->f_code & ~0x70) || !(s->f_code & 0x60)) | |
725 return -1; | |
726 | |
727 /* swap some header bytes (why?) */ | |
728 if (s->f_code != 0x20) { | |
729 uint32_t *src = (uint32_t *) (buf + 4); | |
730 | |
731 for (i=0; i < 4; i++) { | |
732 src[i] = ((src[i] << 16) | (src[i] >> 16)) ^ src[7 - i]; | |
733 } | |
734 } | |
735 | |
528 | 736 result = svq1_decode_frame_header (&s->gb, s); |
521 | 737 |
738 if (result != 0) | |
739 { | |
740 #ifdef DEBUG_SVQ1 | |
2005 | 741 av_log(s->avctx, AV_LOG_INFO, "Error in svq1_decode_frame_header %i\n",result); |
521 | 742 #endif |
743 return result; | |
744 } | |
2967 | 745 |
982
a1866d06df1e
workaround dropable p frame after first frame bug
michaelni
parents:
925
diff
changeset
|
746 //FIXME this avoids some confusion for "B frames" without 2 references |
2005 | 747 //this should be removed after libavcodec can handle more flexible picture types & ordering |
1138 | 748 if(s->pict_type==B_TYPE && s->last_picture_ptr==NULL) return buf_size; |
2967 | 749 |
561 | 750 if(avctx->hurry_up && s->pict_type==B_TYPE) return buf_size; |
2792 | 751 if( (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type==B_TYPE) |
752 ||(avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type!=I_TYPE) | |
753 || avctx->skip_frame >= AVDISCARD_ALL) | |
2967 | 754 return buf_size; |
521 | 755 |
903 | 756 if(MPV_frame_start(s, avctx) < 0) |
757 return -1; | |
758 | |
521 | 759 /* decode y, u and v components */ |
760 for (i=0; i < 3; i++) { | |
557 | 761 int linesize; |
521 | 762 if (i == 0) { |
528 | 763 width = (s->width+15)&~15; |
764 height = (s->height+15)&~15; | |
557 | 765 linesize= s->linesize; |
521 | 766 } else { |
560 | 767 if(s->flags&CODEC_FLAG_GRAY) break; |
528 | 768 width = (s->width/4+15)&~15; |
769 height = (s->height/4+15)&~15; | |
557 | 770 linesize= s->uvlinesize; |
521 | 771 } |
772 | |
903 | 773 current = s->current_picture.data[i]; |
521 | 774 |
557 | 775 if(s->pict_type==B_TYPE){ |
903 | 776 previous = s->next_picture.data[i]; |
557 | 777 }else{ |
903 | 778 previous = s->last_picture.data[i]; |
557 | 779 } |
780 | |
781 if (s->pict_type == I_TYPE) { | |
521 | 782 /* keyframe */ |
783 for (y=0; y < height; y+=16) { | |
2979 | 784 for (x=0; x < width; x+=16) { |
785 result = svq1_decode_block_intra (&s->gb, ¤t[x], linesize); | |
786 if (result != 0) | |
787 { | |
2005 | 788 //#ifdef DEBUG_SVQ1 |
2979 | 789 av_log(s->avctx, AV_LOG_INFO, "Error in svq1_decode_block %i (keyframe)\n",result); |
2005 | 790 //#endif |
2979 | 791 return result; |
792 } | |
793 } | |
794 current += 16*linesize; | |
521 | 795 } |
796 } else { | |
557 | 797 svq1_pmv_t pmv[width/8+3]; |
521 | 798 /* delta frame */ |
557 | 799 memset (pmv, 0, ((width / 8) + 3) * sizeof(svq1_pmv_t)); |
521 | 800 |
801 for (y=0; y < height; y+=16) { | |
2979 | 802 for (x=0; x < width; x+=16) { |
803 result = svq1_decode_delta_block (s, &s->gb, ¤t[x], previous, | |
804 linesize, pmv, x, y); | |
805 if (result != 0) | |
806 { | |
521 | 807 #ifdef DEBUG_SVQ1 |
2005 | 808 av_log(s->avctx, AV_LOG_INFO, "Error in svq1_decode_delta_block %i\n",result); |
521 | 809 #endif |
2979 | 810 return result; |
811 } | |
812 } | |
521 | 813 |
2979 | 814 pmv[0].x = |
815 pmv[0].y = 0; | |
521 | 816 |
2979 | 817 current += 16*linesize; |
521 | 818 } |
819 } | |
903 | 820 } |
2967 | 821 |
925 | 822 *pict = *(AVFrame*)&s->current_picture; |
528 | 823 |
557 | 824 |
903 | 825 MPV_frame_end(s); |
2967 | 826 |
925 | 827 *data_size=sizeof(AVFrame); |
561 | 828 return buf_size; |
521 | 829 } |
830 | |
831 static int svq1_decode_init(AVCodecContext *avctx) | |
832 { | |
833 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
|
834 int i; |
579 | 835 |
1892 | 836 MPV_decode_defaults(s); |
837 | |
521 | 838 s->avctx = avctx; |
839 s->width = (avctx->width+3)&~3; | |
840 s->height = (avctx->height+3)&~3; | |
841 s->codec_id= avctx->codec->id; | |
557 | 842 avctx->pix_fmt = PIX_FMT_YUV410P; |
924 | 843 avctx->has_b_frames= 1; // not true, but DP frames and these behave like unidirectional b frames |
2005 | 844 s->flags= avctx->flags; |
521 | 845 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
|
846 |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
847 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
|
848 &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
|
849 &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
|
850 |
2017 | 851 init_vlc(&svq1_motion_component, 7, 33, |
852 &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
|
853 &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
|
854 |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
855 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
|
856 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
|
857 &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
|
858 &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
|
859 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
|
860 &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
|
861 &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
|
862 } |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
863 |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
864 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
|
865 &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
|
866 &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
|
867 |
00dcdda701ca
rework SVQ1 decoder to use more intuitive VLC tables as well as ffmpeg's
tmmm
parents:
1282
diff
changeset
|
868 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
|
869 &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
|
870 &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
|
871 |
521 | 872 return 0; |
873 } | |
874 | |
875 static int svq1_decode_end(AVCodecContext *avctx) | |
876 { | |
877 MpegEncContext *s = avctx->priv_data; | |
878 | |
879 MPV_common_end(s); | |
880 return 0; | |
881 } | |
882 | |
2005 | 883 static void svq1_write_header(SVQ1Context *s, int frame_type) |
884 { | |
2214 | 885 int i; |
886 | |
2005 | 887 /* frame code */ |
888 put_bits(&s->pb, 22, 0x20); | |
889 | |
890 /* temporal reference (sure hope this is a "don't care") */ | |
891 put_bits(&s->pb, 8, 0x00); | |
892 | |
893 /* frame type */ | |
894 put_bits(&s->pb, 2, frame_type - 1); | |
895 | |
896 if (frame_type == I_TYPE) { | |
897 | |
898 /* no checksum since frame code is 0x20 */ | |
899 | |
900 /* no embedded string either */ | |
901 | |
902 /* output 5 unknown bits (2 + 2 + 1) */ | |
903 put_bits(&s->pb, 5, 0); | |
904 | |
2979 | 905 for (i = 0; i < 7; i++) |
906 { | |
907 if ((svq1_frame_size_table[i].width == s->frame_width) && | |
908 (svq1_frame_size_table[i].height == s->frame_height)) | |
909 { | |
910 put_bits(&s->pb, 3, i); | |
911 break; | |
912 } | |
913 } | |
2967 | 914 |
2979 | 915 if (i == 7) |
916 { | |
917 put_bits(&s->pb, 3, 7); | |
918 put_bits(&s->pb, 12, s->frame_width); | |
919 put_bits(&s->pb, 12, s->frame_height); | |
920 } | |
2005 | 921 } |
922 | |
923 /* no checksum or extra data (next 2 bits get 0) */ | |
924 put_bits(&s->pb, 2, 0); | |
925 } | |
926 | |
927 | |
928 #define QUALITY_THRESHOLD 100 | |
929 #define THRESHOLD_MULTIPLIER 0.6 | |
930 | |
2069
a8100a516b0a
gcc bug workaround by (Jonathan Gray <khalek at linuxgamers dot net>)
michael
parents:
2028
diff
changeset
|
931 #if defined(HAVE_ALTIVEC) |
a8100a516b0a
gcc bug workaround by (Jonathan Gray <khalek at linuxgamers dot net>)
michael
parents:
2028
diff
changeset
|
932 #undef vector |
a8100a516b0a
gcc bug workaround by (Jonathan Gray <khalek at linuxgamers dot net>)
michael
parents:
2028
diff
changeset
|
933 #endif |
2005 | 934 |
2012
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
935 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 | 936 int count, y, x, i, j, split, best_mean, best_score, best_count; |
937 int best_vector[6]; | |
938 int block_sum[7]= {0, 0, 0, 0, 0, 0}; | |
939 int w= 2<<((level+2)>>1); | |
940 int h= 2<<((level+1)>>1); | |
941 int size=w*h; | |
942 int16_t block[7][256]; | |
2011
8c7e7c332b86
using pointers so the code could eventually be used for P frames
michael
parents:
2010
diff
changeset
|
943 const int8_t *codebook_sum, *codebook; |
8c7e7c332b86
using pointers so the code could eventually be used for P frames
michael
parents:
2010
diff
changeset
|
944 const uint16_t (*mean_vlc)[2]; |
8c7e7c332b86
using pointers so the code could eventually be used for P frames
michael
parents:
2010
diff
changeset
|
945 const uint8_t (*multistage_vlc)[2]; |
8c7e7c332b86
using pointers so the code could eventually be used for P frames
michael
parents:
2010
diff
changeset
|
946 |
2012
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
947 best_score=0; |
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
948 //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
|
949 if(intra){ |
8c7e7c332b86
using pointers so the code could eventually be used for P frames
michael
parents:
2010
diff
changeset
|
950 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
|
951 codebook= svq1_intra_codebooks[level]; |
8c7e7c332b86
using pointers so the code could eventually be used for P frames
michael
parents:
2010
diff
changeset
|
952 mean_vlc= svq1_intra_mean_vlc; |
8c7e7c332b86
using pointers so the code could eventually be used for P frames
michael
parents:
2010
diff
changeset
|
953 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
|
954 for(y=0; y<h; y++){ |
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
955 for(x=0; x<w; x++){ |
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
956 int v= src[x + y*stride]; |
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
957 block[0][x + w*y]= v; |
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
958 best_score += v*v; |
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
959 block_sum[0] += v; |
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
960 } |
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
961 } |
2011
8c7e7c332b86
using pointers so the code could eventually be used for P frames
michael
parents:
2010
diff
changeset
|
962 }else{ |
8c7e7c332b86
using pointers so the code could eventually be used for P frames
michael
parents:
2010
diff
changeset
|
963 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
|
964 codebook= svq1_inter_codebooks[level]; |
2012
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
965 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
|
966 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
|
967 for(y=0; y<h; y++){ |
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
968 for(x=0; x<w; x++){ |
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
969 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
|
970 block[0][x + w*y]= v; |
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
971 best_score += v*v; |
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
972 block_sum[0] += v; |
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
973 } |
2007 | 974 } |
975 } | |
976 | |
977 best_count=0; | |
978 best_score -= ((block_sum[0]*block_sum[0])>>(level+3)); | |
979 best_mean= (block_sum[0] + (size>>1)) >> (level+3); | |
980 | |
981 if(level<4){ | |
982 for(count=1; count<7; count++){ | |
983 int best_vector_score= INT_MAX; | |
2012
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
984 int best_vector_sum=-999, best_vector_mean=-999; |
2007 | 985 const int stage= count-1; |
2011
8c7e7c332b86
using pointers so the code could eventually be used for P frames
michael
parents:
2010
diff
changeset
|
986 const int8_t *vector; |
2967 | 987 |
2007 | 988 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
|
989 int sum= codebook_sum[stage*16 + i]; |
2007 | 990 int sqr=0; |
991 int diff, mean, score; | |
2967 | 992 |
2011
8c7e7c332b86
using pointers so the code could eventually be used for P frames
michael
parents:
2010
diff
changeset
|
993 vector = codebook + stage*size*16 + i*size; |
2967 | 994 |
2007 | 995 for(j=0; j<size; j++){ |
996 int v= vector[j]; | |
997 sqr += (v - block[stage][j])*(v - block[stage][j]); | |
998 } | |
999 diff= block_sum[stage] - sum; | |
1000 mean= (diff + (size>>1)) >> (level+3); | |
2012
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
1001 assert(mean >-300 && mean<300); |
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
1002 if(intra) mean= clip(mean, 0, 255); |
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
1003 else mean= clip(mean, -256, 255); |
2007 | 1004 score= sqr - ((diff*(int64_t)diff)>>(level+3)); //FIXME 64bit slooow |
1005 if(score < best_vector_score){ | |
1006 best_vector_score= score; | |
1007 best_vector[stage]= i; | |
1008 best_vector_sum= sum; | |
1009 best_vector_mean= mean; | |
1010 } | |
1011 } | |
2012
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
1012 assert(best_vector_mean != -999); |
2011
8c7e7c332b86
using pointers so the code could eventually be used for P frames
michael
parents:
2010
diff
changeset
|
1013 vector= codebook + stage*size*16 + best_vector[stage]*size; |
2007 | 1014 for(j=0; j<size; j++){ |
1015 block[stage+1][j] = block[stage][j] - vector[j]; | |
1016 } | |
1017 block_sum[stage+1]= block_sum[stage] - best_vector_sum; | |
2967 | 1018 best_vector_score += |
2007 | 1019 lambda*(+ 1 + 4*count |
2011
8c7e7c332b86
using pointers so the code could eventually be used for P frames
michael
parents:
2010
diff
changeset
|
1020 + multistage_vlc[1+count][1] |
8c7e7c332b86
using pointers so the code could eventually be used for P frames
michael
parents:
2010
diff
changeset
|
1021 + mean_vlc[best_vector_mean][1]); |
2967 | 1022 |
2007 | 1023 if(best_vector_score < best_score){ |
1024 best_score= best_vector_score; | |
1025 best_count= count; | |
1026 best_mean= best_vector_mean; | |
1027 } | |
1028 } | |
1029 } | |
2967 | 1030 |
2007 | 1031 split=0; |
1032 if(best_score > threshold && level){ | |
1033 int score=0; | |
1034 int offset= (level&1) ? stride*h/2 : w/2; | |
1035 PutBitContext backup[6]; | |
1036 | |
1037 for(i=level-1; i>=0; i--){ | |
1038 backup[i]= s->reorder_pb[i]; | |
1039 } | |
2012
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
1040 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
|
1041 score += encode_block(s, src + offset, ref + offset, decoded + offset, stride, level-1, threshold>>1, lambda, intra); |
2007 | 1042 score += lambda; |
2967 | 1043 |
2007 | 1044 if(score < best_score){ |
1045 best_score= score; | |
1046 split=1; | |
1047 }else{ | |
1048 for(i=level-1; i>=0; i--){ | |
1049 s->reorder_pb[i]= backup[i]; | |
1050 } | |
1051 } | |
1052 } | |
1053 if (level > 0) | |
1054 put_bits(&s->reorder_pb[level], 1, split); | |
1055 | |
1056 if(!split){ | |
2012
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
1057 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
|
1058 assert(best_mean >= -256 && best_mean<256); |
2007 | 1059 assert(best_count >=0 && best_count<7); |
1060 assert(level<4 || best_count==0); | |
2967 | 1061 |
2007 | 1062 /* output the encoding */ |
2967 | 1063 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
|
1064 multistage_vlc[1 + best_count][1], |
8c7e7c332b86
using pointers so the code could eventually be used for P frames
michael
parents:
2010
diff
changeset
|
1065 multistage_vlc[1 + best_count][0]); |
8c7e7c332b86
using pointers so the code could eventually be used for P frames
michael
parents:
2010
diff
changeset
|
1066 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
|
1067 mean_vlc[best_mean][0]); |
2007 | 1068 |
1069 for (i = 0; i < best_count; i++){ | |
1070 assert(best_vector[i]>=0 && best_vector[i]<16); | |
1071 put_bits(&s->reorder_pb[level], 4, best_vector[i]); | |
1072 } | |
2967 | 1073 |
2012
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
1074 for(y=0; y<h; y++){ |
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
1075 for(x=0; x<w; x++){ |
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
1076 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
|
1077 } |
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
1078 } |
2007 | 1079 } |
1080 | |
1081 return best_score; | |
1082 } | |
1083 | |
2077 | 1084 #ifdef CONFIG_ENCODERS |
1085 | |
2422 | 1086 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
|
1087 int width, int height, int src_stride, int stride) |
2005 | 1088 { |
1089 int x, y; | |
2021 | 1090 int i; |
2005 | 1091 int block_width, block_height; |
1092 int level; | |
1093 int threshold[6]; | |
2012
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
1094 const int lambda= (s->picture.quality*s->picture.quality) >> (2*FF_LAMBDA_SHIFT); |
2005 | 1095 |
1096 /* figure out the acceptable level thresholds in advance */ | |
1097 threshold[5] = QUALITY_THRESHOLD; | |
1098 for (level = 4; level >= 0; level--) | |
1099 threshold[level] = threshold[level + 1] * THRESHOLD_MULTIPLIER; | |
1100 | |
1101 block_width = (width + 15) / 16; | |
1102 block_height = (height + 15) / 16; | |
1103 | |
2017 | 1104 if(s->picture.pict_type == P_TYPE){ |
1105 s->m.avctx= s->avctx; | |
1106 s->m.current_picture_ptr= &s->m.current_picture; | |
1107 s->m.last_picture_ptr = &s->m.last_picture; | |
1108 s->m.last_picture.data[0]= ref_plane; | |
1109 s->m.linesize= | |
2967 | 1110 s->m.last_picture.linesize[0]= |
1111 s->m.new_picture.linesize[0]= | |
2017 | 1112 s->m.current_picture.linesize[0]= stride; |
1113 s->m.width= width; | |
1114 s->m.height= height; | |
1115 s->m.mb_width= block_width; | |
1116 s->m.mb_height= block_height; | |
1117 s->m.mb_stride= s->m.mb_width+1; | |
1118 s->m.b8_stride= 2*s->m.mb_width+1; | |
1119 s->m.f_code=1; | |
1120 s->m.pict_type= s->picture.pict_type; | |
1121 s->m.me_method= s->avctx->me_method; | |
2860 | 1122 s->m.me.scene_change_score=0; |
1123 s->m.flags= s->avctx->flags; | |
1124 // s->m.out_format = FMT_H263; | |
1125 // s->m.unrestricted_mv= 1; | |
2967 | 1126 |
2860 | 1127 s->m.lambda= s->picture.quality; |
1128 s->m.qscale= (s->m.lambda*139 + FF_LAMBDA_SCALE*64) >> (FF_LAMBDA_SHIFT + 7); | |
1129 s->m.lambda2= (s->m.lambda*s->m.lambda + FF_LAMBDA_SCALE/2) >> FF_LAMBDA_SHIFT; | |
2967 | 1130 |
2017 | 1131 if(!s->motion_val8[plane]){ |
2153 | 1132 s->motion_val8 [plane]= av_mallocz((s->m.b8_stride*block_height*2 + 2)*2*sizeof(int16_t)); |
1133 s->motion_val16[plane]= av_mallocz((s->m.mb_stride*(block_height + 2) + 1)*2*sizeof(int16_t)); | |
2017 | 1134 } |
2153 | 1135 |
2017 | 1136 s->m.mb_type= s->mb_type; |
2967 | 1137 |
2017 | 1138 //dummies, to avoid segfaults |
2021 | 1139 s->m.current_picture.mb_mean= (uint8_t *)s->dummy; |
1140 s->m.current_picture.mb_var= (uint16_t*)s->dummy; | |
1141 s->m.current_picture.mc_mb_var= (uint16_t*)s->dummy; | |
2017 | 1142 s->m.current_picture.mb_type= s->dummy; |
2967 | 1143 |
2153 | 1144 s->m.current_picture.motion_val[0]= s->motion_val8[plane] + 2; |
1145 s->m.p_mv_table= s->motion_val16[plane] + s->m.mb_stride + 1; | |
2017 | 1146 s->m.dsp= s->dsp; //move |
1147 ff_init_me(&s->m); | |
2967 | 1148 |
2017 | 1149 s->m.me.dia_size= s->avctx->dia_size; |
1150 s->m.first_slice_line=1; | |
1151 for (y = 0; y < block_height; y++) { | |
1152 uint8_t src[stride*16]; | |
2967 | 1153 |
2017 | 1154 s->m.new_picture.data[0]= src - y*16*stride; //ugly |
1155 s->m.mb_y= y; | |
2967 | 1156 |
2017 | 1157 for(i=0; i<16 && i + 16*y<height; i++){ |
1158 memcpy(&src[i*stride], &src_plane[(i+16*y)*src_stride], width); | |
1159 for(x=width; x<16*block_width; x++) | |
1160 src[i*stride+x]= src[i*stride+x-1]; | |
1161 } | |
1162 for(; i<16 && i + 16*y<16*block_height; i++) | |
1163 memcpy(&src[i*stride], &src[(i-1)*stride], 16*block_width); | |
2967 | 1164 |
2017 | 1165 for (x = 0; x < block_width; x++) { |
1166 s->m.mb_x= x; | |
1167 ff_init_block_index(&s->m); | |
1168 ff_update_block_index(&s->m); | |
2967 | 1169 |
2017 | 1170 ff_estimate_p_frame_motion(&s->m, x, y); |
1171 } | |
1172 s->m.first_slice_line=0; | |
1173 } | |
2967 | 1174 |
2017 | 1175 ff_fix_long_p_mvs(&s->m); |
1176 ff_fix_long_mvs(&s->m, NULL, 0, s->m.p_mv_table, s->m.f_code, CANDIDATE_MB_TYPE_INTER, 0); | |
1177 } | |
2967 | 1178 |
2017 | 1179 s->m.first_slice_line=1; |
2005 | 1180 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
|
1181 uint8_t src[stride*16]; |
2967 | 1182 |
2012
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
1183 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
|
1184 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
|
1185 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
|
1186 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
|
1187 } |
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
1188 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
|
1189 memcpy(&src[i*stride], &src[(i-1)*stride], 16*block_width); |
2005 | 1190 |
2017 | 1191 s->m.mb_y= y; |
2005 | 1192 for (x = 0; x < block_width; x++) { |
2017 | 1193 uint8_t reorder_buffer[3][6][7*32]; |
1194 int count[3][6]; | |
2012
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
1195 int offset = y * 16 * stride + x * 16; |
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
1196 uint8_t *decoded= decoded_plane + offset; |
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
1197 uint8_t *ref= ref_plane + offset; |
2017 | 1198 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
|
1199 uint8_t temp[16*stride]; |
2967 | 1200 |
2422 | 1201 if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < 3000){ //FIXME check size |
1202 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n"); | |
1203 return -1; | |
1204 } | |
2005 | 1205 |
2017 | 1206 s->m.mb_x= x; |
1207 ff_init_block_index(&s->m); | |
1208 ff_update_block_index(&s->m); | |
2967 | 1209 |
2017 | 1210 if(s->picture.pict_type == I_TYPE || (s->m.mb_type[x + y*s->m.mb_stride]&CANDIDATE_MB_TYPE_INTRA)){ |
1211 for(i=0; i<6; i++){ | |
1212 init_put_bits(&s->reorder_pb[i], reorder_buffer[0][i], 7*32); | |
1213 } | |
1214 if(s->picture.pict_type == P_TYPE){ | |
1215 const uint8_t *vlc= svq1_block_type_vlc[SVQ1_BLOCK_INTRA]; | |
1216 put_bits(&s->reorder_pb[5], vlc[1], vlc[0]); | |
1217 score[0]= vlc[1]*lambda; | |
1218 } | |
1219 score[0]+= encode_block(s, src+16*x, NULL, temp, stride, 5, 64, lambda, 1); | |
1220 for(i=0; i<6; i++){ | |
1221 count[0][i]= put_bits_count(&s->reorder_pb[i]); | |
1222 flush_put_bits(&s->reorder_pb[i]); | |
1223 } | |
1224 }else | |
1225 score[0]= INT_MAX; | |
2967 | 1226 |
2017 | 1227 best=0; |
2967 | 1228 |
2012
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
1229 if(s->picture.pict_type == P_TYPE){ |
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
1230 const uint8_t *vlc= svq1_block_type_vlc[SVQ1_BLOCK_INTER]; |
2017 | 1231 int mx, my, pred_x, pred_y, dxy; |
1232 int16_t *motion_ptr; | |
1233 | |
1234 motion_ptr= h263_pred_motion(&s->m, 0, 0, &pred_x, &pred_y); | |
1235 if(s->m.mb_type[x + y*s->m.mb_stride]&CANDIDATE_MB_TYPE_INTER){ | |
1236 for(i=0; i<6; i++) | |
1237 init_put_bits(&s->reorder_pb[i], reorder_buffer[1][i], 7*32); | |
1238 | |
2012
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
1239 put_bits(&s->reorder_pb[5], vlc[1], vlc[0]); |
2967 | 1240 |
1241 s->m.pb= s->reorder_pb[5]; | |
2017 | 1242 mx= motion_ptr[0]; |
1243 my= motion_ptr[1]; | |
1244 assert(mx>=-32 && mx<=31); | |
1245 assert(my>=-32 && my<=31); | |
1246 assert(pred_x>=-32 && pred_x<=31); | |
1247 assert(pred_y>=-32 && pred_y<=31); | |
1248 ff_h263_encode_motion(&s->m, mx - pred_x, 1); | |
1249 ff_h263_encode_motion(&s->m, my - pred_y, 1); | |
1250 s->reorder_pb[5]= s->m.pb; | |
1251 score[1] += lambda*put_bits_count(&s->reorder_pb[5]); | |
2967 | 1252 |
2017 | 1253 dxy= (mx&1) + 2*(my&1); |
2967 | 1254 |
2017 | 1255 s->dsp.put_pixels_tab[0][dxy](temp+16, ref + (mx>>1) + stride*(my>>1), stride, 16); |
2967 | 1256 |
2017 | 1257 score[1]+= encode_block(s, src+16*x, temp+16, decoded, stride, 5, 64, lambda, 0); |
1258 best= score[1] <= score[0]; | |
2018 | 1259 |
1260 vlc= svq1_block_type_vlc[SVQ1_BLOCK_SKIP]; | |
1261 score[2]= s->dsp.sse[0](NULL, src+16*x, ref, stride, 16); | |
1262 score[2]+= vlc[1]*lambda; | |
1263 if(score[2] < score[best] && mx==0 && my==0){ | |
1264 best=2; | |
1265 s->dsp.put_pixels_tab[0][0](decoded, ref, stride, 16); | |
1266 for(i=0; i<6; i++){ | |
1267 count[2][i]=0; | |
1268 } | |
1269 put_bits(&s->pb, vlc[1], vlc[0]); | |
1270 } | |
2012
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
1271 } |
2018 | 1272 |
2012
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
1273 if(best==1){ |
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
1274 for(i=0; i<6; i++){ |
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
1275 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
|
1276 flush_put_bits(&s->reorder_pb[i]); |
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
1277 } |
2017 | 1278 }else{ |
1279 motion_ptr[0 ] = motion_ptr[1 ]= | |
1280 motion_ptr[2 ] = motion_ptr[3 ]= | |
1281 motion_ptr[0+2*s->m.b8_stride] = motion_ptr[1+2*s->m.b8_stride]= | |
1282 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
|
1283 } |
2017 | 1284 } |
2967 | 1285 |
2012
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
1286 s->rd_total += score[best]; |
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
1287 |
2007 | 1288 for(i=5; i>=0; i--){ |
2012
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
1289 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
|
1290 } |
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
1291 if(best==0){ |
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
1292 s->dsp.put_pixels_tab[0][0](decoded, temp, stride, 16); |
2007 | 1293 } |
2005 | 1294 } |
2017 | 1295 s->m.first_slice_line=0; |
2005 | 1296 } |
2422 | 1297 return 0; |
2005 | 1298 } |
1299 | |
1300 static int svq1_encode_init(AVCodecContext *avctx) | |
1301 { | |
1302 SVQ1Context * const s = avctx->priv_data; | |
1303 | |
1304 dsputil_init(&s->dsp, avctx); | |
1305 avctx->coded_frame= (AVFrame*)&s->picture; | |
1306 | |
1307 s->frame_width = avctx->width; | |
1308 s->frame_height = avctx->height; | |
1309 | |
1310 s->y_block_width = (s->frame_width + 15) / 16; | |
1311 s->y_block_height = (s->frame_height + 15) / 16; | |
1312 | |
1313 s->c_block_width = (s->frame_width / 4 + 15) / 16; | |
1314 s->c_block_height = (s->frame_height / 4 + 15) / 16; | |
1315 | |
2017 | 1316 s->avctx= avctx; |
2268 | 1317 s->m.avctx= avctx; |
2967 | 1318 s->m.me.scratchpad= av_mallocz((avctx->width+64)*2*16*2*sizeof(uint8_t)); |
2017 | 1319 s->m.me.map = av_mallocz(ME_MAP_SIZE*sizeof(uint32_t)); |
1320 s->m.me.score_map = av_mallocz(ME_MAP_SIZE*sizeof(uint32_t)); | |
1321 s->mb_type = av_mallocz((s->y_block_width+1)*s->y_block_height*sizeof(int16_t)); | |
1322 s->dummy = av_mallocz((s->y_block_width+1)*s->y_block_height*sizeof(int32_t)); | |
1323 h263_encode_init(&s->m); //mv_penalty | |
2967 | 1324 |
2005 | 1325 return 0; |
1326 } | |
1327 | |
2967 | 1328 static int svq1_encode_frame(AVCodecContext *avctx, unsigned char *buf, |
2005 | 1329 int buf_size, void *data) |
1330 { | |
1331 SVQ1Context * const s = avctx->priv_data; | |
1332 AVFrame *pict = data; | |
1333 AVFrame * const p= (AVFrame*)&s->picture; | |
2012
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
1334 AVFrame temp; |
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
1335 int i; |
2005 | 1336 |
2012
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
1337 if(avctx->pix_fmt != PIX_FMT_YUV410P){ |
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
1338 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
|
1339 return -1; |
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
1340 } |
2967 | 1341 |
2012
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
1342 if(!s->current_picture.data[0]){ |
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
1343 avctx->get_buffer(avctx, &s->current_picture); |
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
1344 avctx->get_buffer(avctx, &s->last_picture); |
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
1345 } |
2967 | 1346 |
2012
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
1347 temp= s->current_picture; |
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
1348 s->current_picture= s->last_picture; |
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
1349 s->last_picture= temp; |
2967 | 1350 |
2005 | 1351 init_put_bits(&s->pb, buf, buf_size); |
1352 | |
1353 *p = *pict; | |
2012
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
1354 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
|
1355 p->key_frame = p->pict_type == I_TYPE; |
2005 | 1356 |
1357 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
|
1358 for(i=0; i<3; i++){ |
2422 | 1359 if(svq1_encode_plane(s, i, |
2012
b7c82b9ef098
p frame encoding, only with 0,0 motion vectors yet though
michael
parents:
2011
diff
changeset
|
1360 s->picture.data[i], s->last_picture.data[i], s->current_picture.data[i], |
2967 | 1361 s->frame_width / (i?4:1), s->frame_height / (i?4:1), |
2422 | 1362 s->picture.linesize[i], s->current_picture.linesize[i]) < 0) |
1363 return -1; | |
2005 | 1364 } |
1365 | |
1366 // align_put_bits(&s->pb); | |
1367 while(put_bits_count(&s->pb) & 31) | |
1368 put_bits(&s->pb, 1, 0); | |
2967 | 1369 |
2008 | 1370 flush_put_bits(&s->pb); |
2005 | 1371 |
1372 return (put_bits_count(&s->pb) / 8); | |
1373 } | |
1374 | |
1375 static int svq1_encode_end(AVCodecContext *avctx) | |
1376 { | |
1377 SVQ1Context * const s = avctx->priv_data; | |
2017 | 1378 int i; |
2005 | 1379 |
2010 | 1380 av_log(avctx, AV_LOG_DEBUG, "RD: %f\n", s->rd_total/(double)(avctx->width*avctx->height*avctx->frame_number)); |
2967 | 1381 |
1382 av_freep(&s->m.me.scratchpad); | |
2017 | 1383 av_freep(&s->m.me.map); |
1384 av_freep(&s->m.me.score_map); | |
1385 av_freep(&s->mb_type); | |
1386 av_freep(&s->dummy); | |
1387 | |
1388 for(i=0; i<3; i++){ | |
1389 av_freep(&s->motion_val8[i]); | |
1390 av_freep(&s->motion_val16[i]); | |
1391 } | |
2005 | 1392 |
1393 return 0; | |
1394 } | |
1395 | |
2077 | 1396 #endif //CONFIG_ENCODERS |
1397 | |
521 | 1398 AVCodec svq1_decoder = { |
1399 "svq1", | |
1400 CODEC_TYPE_VIDEO, | |
1401 CODEC_ID_SVQ1, | |
1402 sizeof(MpegEncContext), | |
1403 svq1_decode_init, | |
1404 NULL, | |
1405 svq1_decode_end, | |
557 | 1406 svq1_decode_frame, |
1407 CODEC_CAP_DR1, | |
1368 | 1408 .flush= ff_mpeg_flush, |
2020 | 1409 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV410P, -1}, |
521 | 1410 }; |
2005 | 1411 |
1412 #ifdef CONFIG_ENCODERS | |
1413 | |
1414 AVCodec svq1_encoder = { | |
1415 "svq1", | |
1416 CODEC_TYPE_VIDEO, | |
1417 CODEC_ID_SVQ1, | |
1418 sizeof(SVQ1Context), | |
1419 svq1_encode_init, | |
1420 svq1_encode_frame, | |
1421 svq1_encode_end, | |
2020 | 1422 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV410P, -1}, |
2005 | 1423 }; |
1424 | |
1425 #endif //CONFIG_ENCODERS |