1
|
1 /*
|
|
2 * slice.c
|
|
3 * Copyright (C) 1999-2000 Aaron Holtzman <aholtzma@ess.engr.uvic.ca>
|
|
4 *
|
|
5 * This file is part of mpeg2dec, a free MPEG-2 video stream decoder.
|
|
6 *
|
|
7 * mpeg2dec is free software; you can redistribute it and/or modify
|
|
8 * it under the terms of the GNU General Public License as published by
|
|
9 * the Free Software Foundation; either version 2 of the License, or
|
|
10 * (at your option) any later version.
|
|
11 *
|
|
12 * mpeg2dec is distributed in the hope that it will be useful,
|
|
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
15 * GNU General Public License for more details.
|
|
16 *
|
|
17 * You should have received a copy of the GNU General Public License
|
|
18 * along with this program; if not, write to the Free Software
|
|
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
20 */
|
|
21
|
|
22 #include "config.h"
|
|
23
|
|
24 #include <inttypes.h>
|
|
25
|
|
26 #include "mpeg2_internal.h"
|
|
27 #include "attributes.h"
|
|
28
|
|
29 // default intra quant matrix, in zig-zag order
|
|
30 static uint8_t default_intra_quantizer_matrix[64] ATTR_ALIGN(16) = {
|
|
31 8,
|
|
32 16, 16,
|
|
33 19, 16, 19,
|
|
34 22, 22, 22, 22,
|
|
35 22, 22, 26, 24, 26,
|
|
36 27, 27, 27, 26, 26, 26,
|
|
37 26, 27, 27, 27, 29, 29, 29,
|
|
38 34, 34, 34, 29, 29, 29, 27, 27,
|
|
39 29, 29, 32, 32, 34, 34, 37,
|
|
40 38, 37, 35, 35, 34, 35,
|
|
41 38, 38, 40, 40, 40,
|
|
42 48, 48, 46, 46,
|
|
43 56, 56, 58,
|
|
44 69, 69,
|
|
45 83
|
|
46 };
|
|
47
|
|
48 uint8_t scan_norm[64] ATTR_ALIGN(16) =
|
|
49 {
|
|
50 // Zig-Zag scan pattern
|
|
51 0, 1, 8,16, 9, 2, 3,10,
|
|
52 17,24,32,25,18,11, 4, 5,
|
|
53 12,19,26,33,40,48,41,34,
|
|
54 27,20,13, 6, 7,14,21,28,
|
|
55 35,42,49,56,57,50,43,36,
|
|
56 29,22,15,23,30,37,44,51,
|
|
57 58,59,52,45,38,31,39,46,
|
|
58 53,60,61,54,47,55,62,63
|
|
59 };
|
|
60
|
|
61 uint8_t scan_alt[64] ATTR_ALIGN(16) =
|
|
62 {
|
|
63 // Alternate scan pattern
|
|
64 0,8,16,24,1,9,2,10,17,25,32,40,48,56,57,49,
|
|
65 41,33,26,18,3,11,4,12,19,27,34,42,50,58,35,43,
|
|
66 51,59,20,28,5,13,6,14,21,29,36,44,52,60,37,45,
|
|
67 53,61,22,30,7,15,23,31,38,46,54,62,39,47,55,63
|
|
68 };
|
|
69
|
|
70 void header_state_init (picture_t * picture)
|
|
71 {
|
|
72 //FIXME we should set pointers to the real scan matrices here (mmx vs
|
|
73 //normal) instead of the ifdefs in header_process_picture_coding_extension
|
|
74
|
|
75 picture->scan = scan_norm;
|
|
76 }
|
|
77
|
|
78 static const int frameratecode2framerate[16] = {
|
|
79 0, 24000*10000/1001, 24*10000,25*10000, 30000*10000/1001, 30*10000,50*10000,60000*10000/1001,
|
|
80 60*10000, 0,0,0,0,0,0,0
|
|
81 };
|
|
82
|
|
83 int header_process_sequence_header (picture_t * picture, uint8_t * buffer)
|
|
84 {
|
|
85 unsigned int h_size;
|
|
86 unsigned int v_size;
|
|
87 int i;
|
|
88
|
|
89 if ((buffer[6] & 0x20) != 0x20)
|
|
90 return 1; // missing marker_bit
|
|
91
|
|
92 v_size = (buffer[0] << 16) | (buffer[1] << 8) | buffer[2];
|
|
93
|
|
94 picture->display_picture_width = (v_size >> 12);
|
|
95 picture->display_picture_height = (v_size & 0xfff);
|
|
96
|
|
97 h_size = ((v_size >> 12) + 15) & ~15;
|
|
98 v_size = ((v_size & 0xfff) + 15) & ~15;
|
|
99
|
|
100 if ((h_size > 768) || (v_size > 576))
|
|
101 return 1; // size restrictions for MP@ML or MPEG1
|
|
102
|
|
103 //XXX this needs field fixups
|
|
104 picture->coded_picture_width = h_size;
|
|
105 picture->coded_picture_height = v_size;
|
|
106 picture->last_mba = ((h_size * v_size) >> 8) - 1;
|
|
107
|
|
108 // this is not used by the decoder
|
|
109 picture->aspect_ratio_information = buffer[3] >> 4;
|
|
110 picture->frame_rate_code = buffer[3] & 15;
|
|
111 picture->frame_rate = frameratecode2framerate[picture->frame_rate_code];
|
|
112
|
|
113 picture->bitrate = (buffer[4]<<10)|(buffer[5]<<2)|(buffer[6]>>6);
|
|
114
|
|
115 if (buffer[7] & 2) {
|
|
116 for (i = 0; i < 64; i++)
|
|
117 picture->intra_quantizer_matrix[scan_norm[i]] =
|
|
118 (buffer[i+7] << 7) | (buffer[i+8] >> 1);
|
|
119 buffer += 64;
|
|
120 } else {
|
|
121 for (i = 0; i < 64; i++)
|
|
122 picture->intra_quantizer_matrix[scan_norm[i]] =
|
|
123 default_intra_quantizer_matrix [i];
|
|
124 }
|
|
125
|
|
126 if (buffer[7] & 1) {
|
|
127 for (i = 0; i < 64; i++)
|
|
128 picture->non_intra_quantizer_matrix[scan_norm[i]] =
|
|
129 buffer[i+8];
|
|
130 } else {
|
|
131 for (i = 0; i < 64; i++)
|
|
132 picture->non_intra_quantizer_matrix[i] = 16;
|
|
133 }
|
|
134
|
|
135 // MPEG1 - for testing only
|
|
136 picture->mpeg1 = 1;
|
|
137 picture->intra_dc_precision = 0;
|
|
138 picture->frame_pred_frame_dct = 1;
|
|
139 picture->q_scale_type = 0;
|
|
140 picture->concealment_motion_vectors = 0;
|
|
141 //picture->alternate_scan = 0;
|
|
142 picture->picture_structure = FRAME_PICTURE;
|
|
143 //picture->second_field = 0;
|
|
144
|
|
145 return 0;
|
|
146 }
|
|
147
|
|
148 static int header_process_sequence_extension (picture_t * picture,
|
|
149 uint8_t * buffer)
|
|
150 {
|
|
151 // MPEG1 - for testing only
|
|
152 picture->mpeg1 = 0;
|
|
153
|
|
154 // check chroma format, size extensions, marker bit
|
|
155 if(((buffer[1]>>1)&3)!=1){
|
|
156 printf("This CHROMA format not yet supported :(\n");
|
|
157 return 1;
|
|
158 }
|
|
159 if ((buffer[1] & 1) || (buffer[2] & 0xe0)){
|
|
160 printf("Big resolution video not yet supported :(\n");
|
|
161 return 1;
|
|
162 }
|
|
163 if((buffer[3] & 0x01) != 0x01) return 1; // marker bit
|
|
164
|
|
165
|
|
166 // this is not used by the decoder
|
|
167 picture->progressive_sequence = (buffer[1] >> 3) & 1;
|
|
168
|
|
169 if (picture->progressive_sequence)
|
|
170 picture->coded_picture_height =
|
|
171 (picture->coded_picture_height + 31) & ~31;
|
|
172 picture->bitrate>>=1; // hack
|
|
173
|
|
174 return 0;
|
|
175 }
|
|
176
|
|
177 static int header_process_quant_matrix_extension (picture_t * picture,
|
|
178 uint8_t * buffer)
|
|
179 {
|
|
180 int i;
|
|
181
|
|
182 if (buffer[0] & 8) {
|
|
183 for (i = 0; i < 64; i++)
|
|
184 picture->intra_quantizer_matrix[scan_norm[i]] =
|
|
185 (buffer[i] << 5) | (buffer[i+1] >> 3);
|
|
186 buffer += 64;
|
|
187 }
|
|
188
|
|
189 if (buffer[0] & 4) {
|
|
190 for (i = 0; i < 64; i++)
|
|
191 picture->non_intra_quantizer_matrix[scan_norm[i]] =
|
|
192 (buffer[i] << 6) | (buffer[i+1] >> 2);
|
|
193 }
|
|
194
|
|
195 return 0;
|
|
196 }
|
|
197
|
|
198 static int header_process_picture_coding_extension (picture_t * picture, uint8_t * buffer)
|
|
199 {
|
|
200 //pre subtract 1 for use later in compute_motion_vector
|
|
201 picture->f_code[0][0] = (buffer[0] & 15) - 1;
|
|
202 picture->f_code[0][1] = (buffer[1] >> 4) - 1;
|
|
203 picture->f_code[1][0] = (buffer[1] & 15) - 1;
|
|
204 picture->f_code[1][1] = (buffer[2] >> 4) - 1;
|
|
205
|
|
206 picture->intra_dc_precision = (buffer[2] >> 2) & 3;
|
|
207 picture->picture_structure = buffer[2] & 3;
|
|
208 picture->frame_pred_frame_dct = (buffer[3] >> 6) & 1;
|
|
209 picture->concealment_motion_vectors = (buffer[3] >> 5) & 1;
|
|
210 picture->q_scale_type = (buffer[3] >> 4) & 1;
|
|
211 picture->intra_vlc_format = (buffer[3] >> 3) & 1;
|
|
212
|
|
213 if (buffer[3] & 4) // alternate_scan
|
|
214 picture->scan = scan_alt;
|
|
215 else
|
|
216 picture->scan = scan_norm;
|
|
217
|
|
218 // these are not used by the decoder
|
|
219 picture->top_field_first = buffer[3] >> 7;
|
|
220 picture->repeat_first_field = (buffer[3] >> 1) & 1;
|
|
221 picture->progressive_frame = buffer[4] >> 7;
|
|
222
|
|
223 // repeat_first implementation by A'rpi/ESP-team, based on libmpeg3:
|
|
224 if(picture->repeat_count>=100) picture->repeat_count=0;
|
|
225 if(picture->repeat_first_field){
|
|
226 if(picture->progressive_sequence){
|
|
227 if(picture->top_field_first)
|
|
228 picture->repeat_count+=200;
|
|
229 else
|
|
230 picture->repeat_count+=100;
|
|
231 } else
|
|
232 if(picture->progressive_frame){
|
|
233 picture->repeat_count+=50;
|
|
234 }
|
|
235 }
|
|
236
|
|
237 return 0;
|
|
238 }
|
|
239
|
|
240 int header_process_extension (picture_t * picture, uint8_t * buffer)
|
|
241 {
|
|
242 switch (buffer[0] & 0xf0) {
|
|
243 case 0x10: // sequence extension
|
|
244 return header_process_sequence_extension (picture, buffer);
|
|
245
|
|
246 case 0x30: // quant matrix extension
|
|
247 return header_process_quant_matrix_extension (picture, buffer);
|
|
248
|
|
249 case 0x80: // picture coding extension
|
|
250 return header_process_picture_coding_extension (picture, buffer);
|
|
251 }
|
|
252
|
|
253 return 0;
|
|
254 }
|
|
255
|
|
256 int header_process_picture_header (picture_t *picture, uint8_t * buffer)
|
|
257 {
|
|
258 picture->picture_coding_type = (buffer [1] >> 3) & 7;
|
|
259
|
|
260 // forward_f_code and backward_f_code - used in mpeg1 only
|
|
261 picture->f_code[0][1] = (buffer[3] >> 2) & 1;
|
|
262 picture->f_code[0][0] =
|
|
263 (((buffer[3] << 1) | (buffer[4] >> 7)) & 7) - 1;
|
|
264 picture->f_code[1][1] = (buffer[4] >> 6) & 1;
|
|
265 picture->f_code[1][0] = ((buffer[4] >> 3) & 7) - 1;
|
|
266
|
|
267 // move in header_process_picture_header
|
|
268 picture->second_field =
|
|
269 (picture->picture_structure != FRAME_PICTURE) &&
|
|
270 !(picture->second_field);
|
|
271
|
|
272 return 0;
|
|
273 }
|