clib/libmpeg2/header.c

filter: Statementstmt 0.0% 0 / 590 Branchbran 0.0% 0 / 242 Conditioncond n/a MC/DCmcdc n/a Subroutinesub n/a Podpod n/a totaltotal 0.0% 0 / 832 CC 0 SCAR 0
CC
0
Cov
0%
CRAP 0
« clib/libmpeg2/decode.c ↑ Summary clib/libmpeg2/idct.c »
1 /*
2 * header.c
3 * Copyright (C) 2000-2003 Michel Lespinasse <walken@zoy.org>
4 * Copyright (C) 2003 Regis Duchesne <hpreg@zoy.org>
5 * Copyright (C) 1999-2000 Aaron Holtzman <aholtzma@ess.engr.uvic.ca>
6 *
7 * This file is part of mpeg2dec, a free MPEG-2 video stream decoder.
8 * See http://libmpeg2.sourceforge.net/ for updates.
9 *
10 * mpeg2dec is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2 of the License, or
13 * (at your option) any later version.
14 *
15 * mpeg2dec is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
19 *
20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, write to the Free Software
22 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
23 */
24  
25 #include "config.h"
26  
27 #include <inttypes.h>
28 #include <stdlib.h> /* defines NULL */
29 #include <string.h> /* memcmp */
30  
31 #include "mpeg2.h"
32 #include "attributes.h"
33 #include "mpeg2_internal.h"
34  
35 #define SEQ_EXT 2
36 #define SEQ_DISPLAY_EXT 4
37 #define QUANT_MATRIX_EXT 8
38 #define COPYRIGHT_EXT 0x10
39 #define PIC_DISPLAY_EXT 0x80
40 #define PIC_CODING_EXT 0x100
41  
42 /* default intra quant matrix, in zig-zag order */
43 static const uint8_t default_intra_quantizer_matrix[64] ATTR_ALIGN(16) = {
44 8,
45 16, 16,
46 19, 16, 19,
47 22, 22, 22, 22,
48 22, 22, 26, 24, 26,
49 27, 27, 27, 26, 26, 26,
50 26, 27, 27, 27, 29, 29, 29,
51 34, 34, 34, 29, 29, 29, 27, 27,
52 29, 29, 32, 32, 34, 34, 37,
53 38, 37, 35, 35, 34, 35,
54 38, 38, 40, 40, 40,
55 48, 48, 46, 46,
56 56, 56, 58,
57 69, 69,
58 83
59 };
60  
61 uint8_t mpeg2_scan_norm[64] ATTR_ALIGN(16) = {
62 /* Zig-Zag scan pattern */
63 0, 1, 8, 16, 9, 2, 3, 10, 17, 24, 32, 25, 18, 11, 4, 5,
64 12, 19, 26, 33, 40, 48, 41, 34, 27, 20, 13, 6, 7, 14, 21, 28,
65 35, 42, 49, 56, 57, 50, 43, 36, 29, 22, 15, 23, 30, 37, 44, 51,
66 58, 59, 52, 45, 38, 31, 39, 46, 53, 60, 61, 54, 47, 55, 62, 63
67 };
68  
69 uint8_t mpeg2_scan_alt[64] ATTR_ALIGN(16) = {
70 /* Alternate scan pattern */
71 0, 8, 16, 24, 1, 9, 2, 10, 17, 25, 32, 40, 48, 56, 57, 49,
72 41, 33, 26, 18, 3, 11, 4, 12, 19, 27, 34, 42, 50, 58, 35, 43,
73 51, 59, 20, 28, 5, 13, 6, 14, 21, 29, 36, 44, 52, 60, 37, 45,
74 53, 61, 22, 30, 7, 15, 23, 31, 38, 46, 54, 62, 39, 47, 55, 63
75 };
76  
77 0 void mpeg2_header_state_init (mpeg2dec_t * mpeg2dec)
78 {
79 0 ▶ if (mpeg2dec->sequence.width != (unsigned)-1) {
Branch: 1 branch
BranchTrueFalseTotal
if (mpeg2dec->sequence.width != (unsigned)-1) { 0 0 0
80 int i;
81  
82 0 mpeg2dec->sequence.width = (unsigned)-1;
83 0 ▶ if (!mpeg2dec->custom_fbuf)
Branch: 1 branch
BranchTrueFalseTotal
if (!mpeg2dec->custom_fbuf) 0 0 0
84 0 for (i = mpeg2dec->alloc_index_user;
85 0 ▶ i < mpeg2dec->alloc_index; i++) {
Branch: 1 branch
BranchTrueFalseTotal
i < mpeg2dec->alloc_index; i++) { 0 0 0
86 0 mpeg2_free (mpeg2dec->fbuf_alloc[i].fbuf.buf[0]);
87 0 mpeg2_free (mpeg2dec->fbuf_alloc[i].fbuf.buf[1]);
88 0 mpeg2_free (mpeg2dec->fbuf_alloc[i].fbuf.buf[2]);
89 }
90 0 ▶ if (mpeg2dec->convert_start)
Branch: 1 branch
BranchTrueFalseTotal
if (mpeg2dec->convert_start) 0 0 0
91 0 ▶ for (i = 0; i < 3; i++) {
Branch: 1 branch
BranchTrueFalseTotal
for (i = 0; i < 3; i++) { 0 0 0
92 0 mpeg2_free (mpeg2dec->yuv_buf[i][0]);
93 0 mpeg2_free (mpeg2dec->yuv_buf[i][1]);
94 0 mpeg2_free (mpeg2dec->yuv_buf[i][2]);
95 }
96 0 ▶ if (mpeg2dec->decoder.convert_id)
Branch: 1 branch
BranchTrueFalseTotal
if (mpeg2dec->decoder.convert_id) 0 0 0
97 0 mpeg2_free (mpeg2dec->decoder.convert_id);
98 }
99 0 mpeg2dec->decoder.coding_type = I_TYPE;
100 0 mpeg2dec->decoder.convert = NULL;
101 0 mpeg2dec->decoder.convert_id = NULL;
102 0 mpeg2dec->picture = mpeg2dec->pictures;
103 0 mpeg2dec->fbuf[0] = &mpeg2dec->fbuf_alloc[0].fbuf;
104 0 mpeg2dec->fbuf[1] = &mpeg2dec->fbuf_alloc[1].fbuf;
105 0 mpeg2dec->fbuf[2] = &mpeg2dec->fbuf_alloc[2].fbuf;
106 0 mpeg2dec->first = 1;
107 0 mpeg2dec->alloc_index = 0;
108 0 mpeg2dec->alloc_index_user = 0;
109 0 mpeg2dec->first_decode_slice = 1;
110 0 mpeg2dec->nb_decode_slices = 0xb0 - 1;
111 0 mpeg2dec->convert = NULL;
112 0 mpeg2dec->convert_start = NULL;
113 0 mpeg2dec->custom_fbuf = 0;
114 0 mpeg2dec->yuv_index = 0;
115 0 }
116  
117 0 void mpeg2_reset_info (mpeg2_info_t * info)
118 {
119 0 info->current_picture = info->current_picture_2nd = NULL;
120 0 info->display_picture = info->display_picture_2nd = NULL;
121 0 info->current_fbuf = info->display_fbuf = info->discard_fbuf = NULL;
122 0 }
123  
124 0 static void info_user_data (mpeg2dec_t * mpeg2dec)
125 {
126 0 ▶ if (mpeg2dec->user_data_len) {
Branch: 1 branch
BranchTrueFalseTotal
if (mpeg2dec->user_data_len) { 0 0 0
127 0 mpeg2dec->info.user_data = mpeg2dec->chunk_buffer;
128 0 mpeg2dec->info.user_data_len = mpeg2dec->user_data_len - 3;
129 }
130 0 }
131  
132 0 int mpeg2_header_sequence (mpeg2dec_t * mpeg2dec)
133 {
134 0 uint8_t * buffer = mpeg2dec->chunk_start;
135 0 mpeg2_sequence_t * sequence = &(mpeg2dec->new_sequence);
136 static unsigned int frame_period[16] = {
137 0, 1126125, 1125000, 1080000, 900900, 900000, 540000, 450450, 450000,
138 /* unofficial: xing 15 fps */
139 1800000,
140 /* unofficial: libmpeg3 "Unofficial economy rates" 5/10/12/15 fps */
141 5400000, 2700000, 2250000, 1800000, 0, 0
142 };
143 int i;
144  
145 0 ▶ if ((buffer[6] & 0x20) != 0x20) /* missing marker_bit */
Branch: 1 branch
BranchTrueFalseTotal
if ((buffer[6] & 0x20) != 0x20) /* missing marker_bit */ 0 0 0
146 0 return 1;
147  
148 0 i = (buffer[0] << 16) | (buffer[1] << 8) | buffer[2];
149 0 ▶ if (! (sequence->display_width = sequence->picture_width = i >> 12))
Branch: 1 branch
BranchTrueFalseTotal
if (! (sequence->display_width = sequence->picture_width = i >> 12)) 0 0 0
150 0 return 1;
151 0 ▶ if (! (sequence->display_height = sequence->picture_height = i & 0xfff))
Branch: 1 branch
BranchTrueFalseTotal
if (! (sequence->display_height = sequence->picture_height = i & 0xfff)) 0 0 0
152 0 return 1;
153 0 sequence->width = (sequence->picture_width + 15) & ~15;
154 0 sequence->height = (sequence->picture_height + 15) & ~15;
155 0 sequence->chroma_width = sequence->width >> 1;
156 0 sequence->chroma_height = sequence->height >> 1;
157  
158 0 sequence->flags = (SEQ_FLAG_PROGRESSIVE_SEQUENCE |
159 SEQ_VIDEO_FORMAT_UNSPECIFIED);
160  
161 0 sequence->pixel_width = buffer[3] >> 4; /* aspect ratio */
162 0 sequence->frame_period = frame_period[buffer[3] & 15];
163  
164 0 sequence->byte_rate = (buffer[4]<<10) | (buffer[5]<<2) | (buffer[6]>>6);
165  
166 0 sequence->vbv_buffer_size = ((buffer[6]<<16)|(buffer[7]<<8))&0x1ff800;
167  
168 0 ▶ if (buffer[7] & 4)
Branch: 1 branch
BranchTrueFalseTotal
if (buffer[7] & 4) 0 0 0
169 0 sequence->flags |= SEQ_FLAG_CONSTRAINED_PARAMETERS;
170  
171 0 mpeg2dec->copy_matrix = 3;
172 0 ▶ if (buffer[7] & 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (buffer[7] & 2) { 0 0 0
173 0 ▶ for (i = 0; i < 64; i++)
Branch: 1 branch
BranchTrueFalseTotal
for (i = 0; i < 64; i++) 0 0 0
174 0 mpeg2dec->new_quantizer_matrix[0][mpeg2_scan_norm[i]] =
175 0 (buffer[i+7] << 7) | (buffer[i+8] >> 1);
176 0 buffer += 64;
177 } else
178 0 ▶ for (i = 0; i < 64; i++)
Branch: 1 branch
BranchTrueFalseTotal
for (i = 0; i < 64; i++) 0 0 0
179 0 mpeg2dec->new_quantizer_matrix[0][mpeg2_scan_norm[i]] =
180 0 default_intra_quantizer_matrix[i];
181  
182 0 ▶ if (buffer[7] & 1)
Branch: 1 branch
BranchTrueFalseTotal
if (buffer[7] & 1) 0 0 0
183 0 ▶ for (i = 0; i < 64; i++)
Branch: 1 branch
BranchTrueFalseTotal
for (i = 0; i < 64; i++) 0 0 0
184 0 mpeg2dec->new_quantizer_matrix[1][mpeg2_scan_norm[i]] =
185 0 buffer[i+8];
186 else
187 0 memset (mpeg2dec->new_quantizer_matrix[1], 16, 64);
188  
189 0 sequence->profile_level_id = 0x80;
190 0 sequence->colour_primaries = 0;
191 0 sequence->transfer_characteristics = 0;
192 0 sequence->matrix_coefficients = 0;
193  
194 0 mpeg2dec->ext_state = SEQ_EXT;
195 0 mpeg2dec->state = STATE_SEQUENCE;
196 0 mpeg2dec->display_offset_x = mpeg2dec->display_offset_y = 0;
197  
198 0 return 0;
199 }
200  
201 0 static int sequence_ext (mpeg2dec_t * mpeg2dec)
202 {
203 0 uint8_t * buffer = mpeg2dec->chunk_start;
204 0 mpeg2_sequence_t * sequence = &(mpeg2dec->new_sequence);
205 uint32_t flags;
206  
207 0 ▶ if (!(buffer[3] & 1))
Branch: 1 branch
BranchTrueFalseTotal
if (!(buffer[3] & 1)) 0 0 0
208 0 return 1;
209  
210 0 sequence->profile_level_id = (buffer[0] << 4) | (buffer[1] >> 4);
211  
212 0 sequence->display_width = sequence->picture_width +=
213 0 ((buffer[1] << 13) | (buffer[2] << 5)) & 0x3000;
214 0 sequence->display_height = sequence->picture_height +=
215 0 (buffer[2] << 7) & 0x3000;
216 0 sequence->width = (sequence->picture_width + 15) & ~15;
217 0 sequence->height = (sequence->picture_height + 15) & ~15;
218 0 flags = sequence->flags | SEQ_FLAG_MPEG2;
219 0 ▶ if (!(buffer[1] & 8)) {
Branch: 1 branch
BranchTrueFalseTotal
if (!(buffer[1] & 8)) { 0 0 0
220 0 flags &= ~SEQ_FLAG_PROGRESSIVE_SEQUENCE;
221 0 sequence->height = (sequence->height + 31) & ~31;
222 }
223 0 ▶ if (buffer[5] & 0x80)
Branch: 1 branch
BranchTrueFalseTotal
if (buffer[5] & 0x80) 0 0 0
224 0 flags |= SEQ_FLAG_LOW_DELAY;
225 0 sequence->flags = flags;
226 0 sequence->chroma_width = sequence->width;
227 0 sequence->chroma_height = sequence->height;
228 0 switch (buffer[1] & 6) {
229 0 case 0: /* invalid */
230 0 return 1;
231 0 case 2: /* 4:2:0 */
232 0 sequence->chroma_height >>= 1;
233 0 case 4: /* 4:2:2 */
234 0 sequence->chroma_width >>= 1;
235 }
236  
237 0 sequence->byte_rate += ((buffer[2]<<25) | (buffer[3]<<17)) & 0x3ffc0000;
238  
239 0 sequence->vbv_buffer_size |= buffer[4] << 21;
240  
241 0 sequence->frame_period =
242 0 sequence->frame_period * ((buffer[5]&31)+1) / (((buffer[5]>>5)&3)+1);
243  
244 0 mpeg2dec->ext_state = SEQ_DISPLAY_EXT;
245  
246 0 return 0;
247 }
248  
249 0 static int sequence_display_ext (mpeg2dec_t * mpeg2dec)
250 {
251 0 uint8_t * buffer = mpeg2dec->chunk_start;
252 0 mpeg2_sequence_t * sequence = &(mpeg2dec->new_sequence);
253  
254 0 sequence->flags = ((sequence->flags & ~SEQ_MASK_VIDEO_FORMAT) |
255 0 ((buffer[0]<<4) & SEQ_MASK_VIDEO_FORMAT));
256 0 ▶ if (buffer[0] & 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (buffer[0] & 1) { 0 0 0
257 0 sequence->flags |= SEQ_FLAG_COLOUR_DESCRIPTION;
258 0 sequence->colour_primaries = buffer[1];
259 0 sequence->transfer_characteristics = buffer[2];
260 0 sequence->matrix_coefficients = buffer[3];
261 0 buffer += 3;
262 }
263  
264 0 ▶ if (!(buffer[2] & 2)) /* missing marker_bit */
Branch: 1 branch
BranchTrueFalseTotal
if (!(buffer[2] & 2)) /* missing marker_bit */ 0 0 0
265 0 return 1;
266  
267 0 ▶ if( (buffer[1] << 6) | (buffer[2] >> 2) )
Branch: 1 branch
BranchTrueFalseTotal
if( (buffer[1] << 6) | (buffer[2] >> 2) ) 0 0 0
268 0 sequence->display_width = (buffer[1] << 6) | (buffer[2] >> 2);
269 0 ▶ if( ((buffer[2]& 1 ) << 13) | (buffer[3] << 5) | (buffer[4] >> 3) )
Branch: 1 branch
BranchTrueFalseTotal
if( ((buffer[2]& 1 ) << 13) | (buffer[3] << 5) | (buffer[4] >> 3) ) 0 0 0
270 0 sequence->display_height =
271 0 ((buffer[2]& 1 ) << 13) | (buffer[3] << 5) | (buffer[4] >> 3);
272  
273 0 return 0;
274 }
275  
276 0 static inline void simplify (unsigned int * u, unsigned int * v)
277 {
278 unsigned int a, b, tmp;
279  
280 0 a = *u; b = *v;
281 0 ▶ while (a) { /* find greatest common divisor */
Branch: 1 branch
BranchTrueFalseTotal
while (a) { /* find greatest common divisor */ 0 0 0
282 0 tmp = a; a = b % tmp; b = tmp;
283 }
284 0 *u /= b; *v /= b;
285 0 }
286  
287 0 static inline void finalize_sequence (mpeg2_sequence_t * sequence)
288 {
289 int width;
290 int height;
291  
292 0 sequence->byte_rate *= 50;
293  
294 0 ▶ if (sequence->flags & SEQ_FLAG_MPEG2) {
Branch: 1 branch
BranchTrueFalseTotal
if (sequence->flags & SEQ_FLAG_MPEG2) { 0 0 0
295 0 switch (sequence->pixel_width) {
296 0 case 1: /* square pixels */
297 0 sequence->pixel_width = sequence->pixel_height = 1; return;
298 0 case 2: /* 4:3 aspect ratio */
299 0 width = 4; height = 3; break;
300 0 case 3: /* 16:9 aspect ratio */
301 0 width = 16; height = 9; break;
302 0 case 4: /* 2.21:1 aspect ratio */
303 0 width = 221; height = 100; break;
304 0 default: /* illegal */
305 0 sequence->pixel_width = sequence->pixel_height = 0; return;
306 }
307 0 width *= sequence->display_height;
308 0 height *= sequence->display_width;
309  
310 } else {
311 0 ▶ if (sequence->byte_rate == 50 * 0x3ffff)
Branch: 1 branch
BranchTrueFalseTotal
if (sequence->byte_rate == 50 * 0x3ffff) 0 0 0
312 0 sequence->byte_rate = 0; /* mpeg-1 VBR */
313  
314 0 switch (sequence->pixel_width) {
315 0 case 0: case 15: /* illegal */
316 0 sequence->pixel_width = sequence->pixel_height = 0; return;
317 0 case 1: /* square pixels */
318 0 sequence->pixel_width = sequence->pixel_height = 1; return;
319 0 case 3: /* 720x576 16:9 */
320 0 sequence->pixel_width = 64; sequence->pixel_height = 45; return;
321 0 case 6: /* 720x480 16:9 */
322 0 sequence->pixel_width = 32; sequence->pixel_height = 27; return;
323 0 case 8: /* BT.601 625 lines 4:3 */
324 0 sequence->pixel_width = 59; sequence->pixel_height = 54; return;
325 0 case 12: /* BT.601 525 lines 4:3 */
326 0 sequence->pixel_width = 10; sequence->pixel_height = 11; return;
327 0 default:
328 0 height = 88 * sequence->pixel_width + 1171;
329 0 width = 2000;
330 }
331 }
332  
333 0 sequence->pixel_width = width;
334 0 sequence->pixel_height = height;
335 0 simplify (&sequence->pixel_width, &sequence->pixel_height);
336 }
337  
338 0 int mpeg2_guess_aspect (const mpeg2_sequence_t * sequence,
339 unsigned int * pixel_width,
340 unsigned int * pixel_height)
341 {
342 static struct {
343 unsigned int width, height;
344 } video_modes[] = {
345 {720, 576}, /* 625 lines, 13.5 MHz (D1, DV, DVB, DVD) */
346 {704, 576}, /* 625 lines, 13.5 MHz (1/1 D1, DVB, DVD, 4CIF) */
347 {544, 576}, /* 625 lines, 10.125 MHz (DVB, laserdisc) */
348 {528, 576}, /* 625 lines, 10.125 MHz (3/4 D1, DVB, laserdisc) */
349 {480, 576}, /* 625 lines, 9 MHz (2/3 D1, DVB, SVCD) */
350 {352, 576}, /* 625 lines, 6.75 MHz (D2, 1/2 D1, CVD, DVB, DVD) */
351 {352, 288}, /* 625 lines, 6.75 MHz, 1 field (D4, VCD, DVB, DVD, CIF) */
352 {176, 144}, /* 625 lines, 3.375 MHz, half field (QCIF) */
353 {720, 486}, /* 525 lines, 13.5 MHz (D1) */
354 {704, 486}, /* 525 lines, 13.5 MHz */
355 {720, 480}, /* 525 lines, 13.5 MHz (DV, DSS, DVD) */
356 {704, 480}, /* 525 lines, 13.5 MHz (1/1 D1, ATSC, DVD) */
357 {544, 480}, /* 525 lines. 10.125 MHz (DSS, laserdisc) */
358 {528, 480}, /* 525 lines. 10.125 MHz (3/4 D1, laserdisc) */
359 {480, 480}, /* 525 lines, 9 MHz (2/3 D1, SVCD) */
360 {352, 480}, /* 525 lines, 6.75 MHz (D2, 1/2 D1, CVD, DVD) */
361 {352, 240} /* 525 lines. 6.75 MHz, 1 field (D4, VCD, DSS, DVD) */
362 };
363 unsigned int width, height, pix_width, pix_height, i, DAR_16_9;
364  
365 0 *pixel_width = sequence->pixel_width;
366 0 *pixel_height = sequence->pixel_height;
367 0 width = sequence->picture_width;
368 0 height = sequence->picture_height;
369 0 ▶ for (i = 0; i < sizeof (video_modes) / sizeof (video_modes[0]); i++)
Branch: 1 branch
BranchTrueFalseTotal
for (i = 0; i < sizeof (video_modes) / sizeof (video_modes[0]); i++) 0 0 0
370 0 ▶ if (width == video_modes[i].width && height == video_modes[i].height)
Branch: 2 branches
BranchTrueFalseTotal
if (width == video_modes[i].width && height == video_modes[i].height) 0 0 0
if (width == video_modes[i].width && height == video_modes[i].height) 0 0 0
371 0 break;
372 0 ▶ if (i == sizeof (video_modes) / sizeof (video_modes[0]) ||
Branch: 1 branch
BranchTrueFalseTotal
if (i == sizeof (video_modes) / sizeof (video_modes[0]) || 0 0 0
373 0 ▶ (sequence->pixel_width == 1 && sequence->pixel_height == 1) ||
Branch: 2 branches
BranchTrueFalseTotal
(sequence->pixel_width == 1 && sequence->pixel_height == 1) || 0 0 0
(sequence->pixel_width == 1 && sequence->pixel_height == 1) || 0 0 0
374 0 ▶ width != sequence->display_width || height != sequence->display_height)
Branch: 2 branches
BranchTrueFalseTotal
width != sequence->display_width || height != sequence->display_height) 0 0 0
width != sequence->display_width || height != sequence->display_height) 0 0 0
375 0 return 0;
376  
377 0 ▶ for (pix_height = 1; height * pix_height < 480; pix_height <<= 1);
Branch: 1 branch
BranchTrueFalseTotal
for (pix_height = 1; height * pix_height < 480; pix_height <<= 1); 0 0 0
378 0 height *= pix_height;
379 0 ▶ for (pix_width = 1; width * pix_width <= 352; pix_width <<= 1);
Branch: 1 branch
BranchTrueFalseTotal
for (pix_width = 1; width * pix_width <= 352; pix_width <<= 1); 0 0 0
380 0 width *= pix_width;
381  
382 0 ▶ if (! (sequence->flags & SEQ_FLAG_MPEG2)) {
Branch: 1 branch
BranchTrueFalseTotal
if (! (sequence->flags & SEQ_FLAG_MPEG2)) { 0 0 0
383 static unsigned int mpeg1_check[2][2] = {{11, 54}, {27, 45}};
384 0 ▶ DAR_16_9 = (sequence->pixel_height == 27 ||
Branch: 1 branch
BranchTrueFalseTotal
DAR_16_9 = (sequence->pixel_height == 27 || 0 0 0
385 0 ▶ sequence->pixel_height == 45);
Branch: 1 branch
BranchTrueFalseTotal
sequence->pixel_height == 45); 0 0 0
386 0 ▶ if (width < 704 ||
Branch: 1 branch
BranchTrueFalseTotal
if (width < 704 || 0 0 0
387 0 ▶ sequence->pixel_height != mpeg1_check[DAR_16_9][height == 576])
Branch: 1 branch
BranchTrueFalseTotal
sequence->pixel_height != mpeg1_check[DAR_16_9][height == 576]) 0 0 0
388 0 return 0;
389 } else {
390 0 DAR_16_9 = (3 * sequence->picture_width * sequence->pixel_width >
391 0 4 * sequence->picture_height * sequence->pixel_height);
392 0 switch (width) {
393 0 case 528: case 544: pix_width *= 4; pix_height *= 3; break;
394 0 case 480: pix_width *= 3; pix_height *= 2; break;
395 }
396 }
397 0 ▶ if (DAR_16_9) {
Branch: 1 branch
BranchTrueFalseTotal
if (DAR_16_9) { 0 0 0
398 0 pix_width *= 4; pix_height *= 3;
399 }
400 0 ▶ if (height == 576) {
Branch: 1 branch
BranchTrueFalseTotal
if (height == 576) { 0 0 0
401 0 pix_width *= 59; pix_height *= 54;
402 } else {
403 0 pix_width *= 10; pix_height *= 11;
404 }
405 0 *pixel_width = pix_width;
406 0 *pixel_height = pix_height;
407 0 simplify (pixel_width, pixel_height);
408 0 ▶ return (height == 576) ? 1 : 2;
Branch: 1 branch
BranchTrueFalseTotal
return (height == 576) ? 1 : 2; 0 0 0
409 }
410  
411 0 static void copy_matrix (mpeg2dec_t * mpeg2dec, int idx)
412 {
413 0 if (memcmp (mpeg2dec->quantizer_matrix[idx],
414 0 ▶ mpeg2dec->new_quantizer_matrix[idx], 64)) {
Branch: 1 branch
BranchTrueFalseTotal
mpeg2dec->new_quantizer_matrix[idx], 64)) { 0 0 0
415 0 memcpy (mpeg2dec->quantizer_matrix[idx],
416 0 mpeg2dec->new_quantizer_matrix[idx], 64);
417 0 mpeg2dec->scaled[idx] = -1;
418 }
419 0 }
420  
421 0 static void finalize_matrix (mpeg2dec_t * mpeg2dec)
422 {
423 0 mpeg2_decoder_t * decoder = &(mpeg2dec->decoder);
424 int i;
425  
426 0 ▶ for (i = 0; i < 2; i++) {
Branch: 1 branch
BranchTrueFalseTotal
for (i = 0; i < 2; i++) { 0 0 0
427 0 ▶ if (mpeg2dec->copy_matrix & (1 << i))
Branch: 1 branch
BranchTrueFalseTotal
if (mpeg2dec->copy_matrix & (1 << i)) 0 0 0
428 0 copy_matrix (mpeg2dec, i);
429 0 ▶ if ((mpeg2dec->copy_matrix & (4 << i)) &&
Branch: 1 branch
BranchTrueFalseTotal
if ((mpeg2dec->copy_matrix & (4 << i)) && 0 0 0
430 0 memcmp (mpeg2dec->quantizer_matrix[i],
431 0 ▶ mpeg2dec->new_quantizer_matrix[i+2], 64)) {
Branch: 1 branch
BranchTrueFalseTotal
mpeg2dec->new_quantizer_matrix[i+2], 64)) { 0 0 0
432 0 copy_matrix (mpeg2dec, i + 2);
433 0 decoder->chroma_quantizer[i] = decoder->quantizer_prescale[i+2];
434 0 ▶ } else if (mpeg2dec->copy_matrix & (5 << i))
Branch: 1 branch
BranchTrueFalseTotal
} else if (mpeg2dec->copy_matrix & (5 << i)) 0 0 0
435 0 decoder->chroma_quantizer[i] = decoder->quantizer_prescale[i];
436 }
437 0 }
438  
439 0 static mpeg2_state_t invalid_end_action (mpeg2dec_t * mpeg2dec)
440 {
441 0 mpeg2_reset_info (&(mpeg2dec->info));
442 0 mpeg2dec->info.gop = NULL;
443 0 info_user_data (mpeg2dec);
444 0 mpeg2_header_state_init (mpeg2dec);
445 0 mpeg2dec->sequence = mpeg2dec->new_sequence;
446 0 mpeg2dec->action = mpeg2_seek_header;
447 0 mpeg2dec->state = STATE_SEQUENCE;
448 0 return STATE_SEQUENCE;
449 }
450  
451 0 void mpeg2_header_sequence_finalize (mpeg2dec_t * mpeg2dec)
452 {
453 0 mpeg2_sequence_t * sequence = &(mpeg2dec->new_sequence);
454 0 mpeg2_decoder_t * decoder = &(mpeg2dec->decoder);
455  
456 0 finalize_sequence (sequence);
457 0 finalize_matrix (mpeg2dec);
458  
459 0 decoder->mpeg1 = !(sequence->flags & SEQ_FLAG_MPEG2);
460 0 decoder->width = sequence->width;
461 0 decoder->height = sequence->height;
462 0 decoder->vertical_position_extension = (sequence->picture_height > 2800);
463 0 decoder->chroma_format = ((sequence->chroma_width == sequence->width) +
464 0 (sequence->chroma_height == sequence->height));
465  
466 0 ▶ if (mpeg2dec->sequence.width != (unsigned)-1) {
Branch: 1 branch
BranchTrueFalseTotal
if (mpeg2dec->sequence.width != (unsigned)-1) { 0 0 0
467 /*
468 * According to 6.1.1.6, repeat sequence headers should be
469 * identical to the original. However some encoders do not
470 * respect that and change various fields (including bitrate
471 * and aspect ratio) in the repeat sequence headers. So we
472 * choose to be as conservative as possible and only restart
473 * the decoder if the width, height, chroma_width,
474 * chroma_height or low_delay flag are modified.
475 */
476 0 ▶ if (sequence->width != mpeg2dec->sequence.width ||
Branch: 1 branch
BranchTrueFalseTotal
if (sequence->width != mpeg2dec->sequence.width || 0 0 0
477 0 ▶ sequence->height != mpeg2dec->sequence.height ||
Branch: 1 branch
BranchTrueFalseTotal
sequence->height != mpeg2dec->sequence.height || 0 0 0
478 0 ▶ sequence->chroma_width != mpeg2dec->sequence.chroma_width ||
Branch: 1 branch
BranchTrueFalseTotal
sequence->chroma_width != mpeg2dec->sequence.chroma_width || 0 0 0
479 0 ▶ sequence->chroma_height != mpeg2dec->sequence.chroma_height ||
Branch: 1 branch
BranchTrueFalseTotal
sequence->chroma_height != mpeg2dec->sequence.chroma_height || 0 0 0
480 0 ▶ ((sequence->flags ^ mpeg2dec->sequence.flags) &
Branch: 1 branch
BranchTrueFalseTotal
((sequence->flags ^ mpeg2dec->sequence.flags) & 0 0 0
481 SEQ_FLAG_LOW_DELAY)) {
482 0 decoder->stride_frame = sequence->width;
483 0 mpeg2_header_end (mpeg2dec);
484 0 mpeg2dec->action = invalid_end_action;
485 0 mpeg2dec->state = STATE_INVALID_END;
486 0 return;
487 }
488 0 mpeg2dec->state = (memcmp (&(mpeg2dec->sequence), sequence,
489 sizeof (mpeg2_sequence_t)) ?
490 0 ▶ STATE_SEQUENCE_MODIFIED : STATE_SEQUENCE_REPEATED);
Branch: 1 branch
BranchTrueFalseTotal
STATE_SEQUENCE_MODIFIED : STATE_SEQUENCE_REPEATED); 0 0 0
491 } else
492 0 decoder->stride_frame = sequence->width;
493 0 mpeg2dec->sequence = *sequence;
494 0 mpeg2_reset_info (&(mpeg2dec->info));
495 0 mpeg2dec->info.sequence = &(mpeg2dec->sequence);
496 0 mpeg2dec->info.gop = NULL;
497 0 info_user_data (mpeg2dec);
498 }
499  
500 0 int mpeg2_header_gop (mpeg2dec_t * mpeg2dec)
501 {
502 0 uint8_t * buffer = mpeg2dec->chunk_start;
503 0 mpeg2_gop_t * gop = &(mpeg2dec->new_gop);
504  
505 0 ▶ if (! (buffer[1] & 8))
Branch: 1 branch
BranchTrueFalseTotal
if (! (buffer[1] & 8)) 0 0 0
506 0 return 1;
507 0 gop->hours = (buffer[0] >> 2) & 31;
508 0 gop->minutes = ((buffer[0] << 4) | (buffer[1] >> 4)) & 63;
509 0 gop->seconds = ((buffer[1] << 3) | (buffer[2] >> 5)) & 63;
510 0 gop->pictures = ((buffer[2] << 1) | (buffer[3] >> 7)) & 63;
511 0 gop->flags = (buffer[0] >> 7) | ((buffer[3] >> 4) & 6);
512 0 mpeg2dec->state = STATE_GOP;
513 0 return 0;
514 }
515  
516 0 void mpeg2_header_gop_finalize (mpeg2dec_t * mpeg2dec)
517 {
518 0 mpeg2dec->gop = mpeg2dec->new_gop;
519 0 mpeg2_reset_info (&(mpeg2dec->info));
520 0 mpeg2dec->info.gop = &(mpeg2dec->gop);
521 0 info_user_data (mpeg2dec);
522 0 }
523  
524 0 void mpeg2_set_fbuf (mpeg2dec_t * mpeg2dec, int b_type)
525 {
526 int i;
527  
528 0 ▶ for (i = 0; i < 3; i++)
Branch: 1 branch
BranchTrueFalseTotal
for (i = 0; i < 3; i++) 0 0 0
529 0 ▶ if (mpeg2dec->fbuf[1] != &mpeg2dec->fbuf_alloc[i].fbuf &&
Branch: 1 branch
BranchTrueFalseTotal
if (mpeg2dec->fbuf[1] != &mpeg2dec->fbuf_alloc[i].fbuf && 0 0 0
530 0 ▶ mpeg2dec->fbuf[2] != &mpeg2dec->fbuf_alloc[i].fbuf) {
Branch: 1 branch
BranchTrueFalseTotal
mpeg2dec->fbuf[2] != &mpeg2dec->fbuf_alloc[i].fbuf) { 0 0 0
531 0 mpeg2dec->fbuf[0] = &mpeg2dec->fbuf_alloc[i].fbuf;
532 0 mpeg2dec->info.current_fbuf = mpeg2dec->fbuf[0];
533 0 ▶ if (b_type || (mpeg2dec->sequence.flags & SEQ_FLAG_LOW_DELAY)) {
Branch: 2 branches
BranchTrueFalseTotal
if (b_type || (mpeg2dec->sequence.flags & SEQ_FLAG_LOW_DELAY)) { 0 0 0
if (b_type || (mpeg2dec->sequence.flags & SEQ_FLAG_LOW_DELAY)) { 0 0 0
534 0 ▶ if (b_type || mpeg2dec->convert)
Branch: 2 branches
BranchTrueFalseTotal
if (b_type || mpeg2dec->convert) 0 0 0
if (b_type || mpeg2dec->convert) 0 0 0
535 0 mpeg2dec->info.discard_fbuf = mpeg2dec->fbuf[0];
536 0 mpeg2dec->info.display_fbuf = mpeg2dec->fbuf[0];
537 }
538 0 break;
539 }
540 0 }
541  
542 0 int mpeg2_header_picture (mpeg2dec_t * mpeg2dec)
543 {
544 0 uint8_t * buffer = mpeg2dec->chunk_start;
545 0 mpeg2_picture_t * picture = &(mpeg2dec->new_picture);
546 0 mpeg2_decoder_t * decoder = &(mpeg2dec->decoder);
547 int type;
548  
549 0 mpeg2dec->state = ((mpeg2dec->state != STATE_SLICE_1ST) ?
550 0 ▶ STATE_PICTURE : STATE_PICTURE_2ND);
Branch: 1 branch
BranchTrueFalseTotal
STATE_PICTURE : STATE_PICTURE_2ND); 0 0 0
551 0 mpeg2dec->ext_state = PIC_CODING_EXT;
552  
553 0 picture->temporal_reference = (buffer[0] << 2) | (buffer[1] >> 6);
554  
555 0 type = (buffer [1] >> 3) & 7;
556 0 ▶ if (type == PIC_FLAG_CODING_TYPE_P || type == PIC_FLAG_CODING_TYPE_B) {
Branch: 2 branches
BranchTrueFalseTotal
if (type == PIC_FLAG_CODING_TYPE_P || type == PIC_FLAG_CODING_TYPE_B) { 0 0 0
if (type == PIC_FLAG_CODING_TYPE_P || type == PIC_FLAG_CODING_TYPE_B) { 0 0 0
557 /* forward_f_code and backward_f_code - used in mpeg1 only */
558 0 decoder->f_motion.f_code[1] = (buffer[3] >> 2) & 1;
559 0 decoder->f_motion.f_code[0] =
560 0 (((buffer[3] << 1) | (buffer[4] >> 7)) & 7) - 1;
561 0 decoder->b_motion.f_code[1] = (buffer[4] >> 6) & 1;
562 0 decoder->b_motion.f_code[0] = ((buffer[4] >> 3) & 7) - 1;
563 }
564  
565 0 picture->flags = PIC_FLAG_PROGRESSIVE_FRAME | type;
566 0 picture->tag = picture->tag2 = 0;
567 0 ▶ if (mpeg2dec->num_tags) {
Branch: 1 branch
BranchTrueFalseTotal
if (mpeg2dec->num_tags) { 0 0 0
568 0 ▶ if (mpeg2dec->bytes_since_tag >= mpeg2dec->chunk_ptr - buffer + 4) {
Branch: 1 branch
BranchTrueFalseTotal
if (mpeg2dec->bytes_since_tag >= mpeg2dec->chunk_ptr - buffer + 4) { 0 0 0
569 0 mpeg2dec->num_tags = 0;
570 0 picture->tag = mpeg2dec->tag_current;
571 0 picture->tag2 = mpeg2dec->tag2_current;
572 0 picture->flags |= PIC_FLAG_TAGS;
573 0 ▶ } else if (mpeg2dec->num_tags > 1) {
Branch: 1 branch
BranchTrueFalseTotal
} else if (mpeg2dec->num_tags > 1) { 0 0 0
574 0 mpeg2dec->num_tags = 1;
575 0 picture->tag = mpeg2dec->tag_previous;
576 0 picture->tag2 = mpeg2dec->tag2_previous;
577 0 picture->flags |= PIC_FLAG_TAGS;
578 }
579 }
580 0 picture->nb_fields = 2;
581 0 picture->display_offset[0].x = picture->display_offset[1].x =
582 0 picture->display_offset[2].x = mpeg2dec->display_offset_x;
583 0 picture->display_offset[0].y = picture->display_offset[1].y =
584 0 picture->display_offset[2].y = mpeg2dec->display_offset_y;
585  
586 /* XXXXXX decode extra_information_picture as well */
587  
588 0 decoder->q_scale_type = 0;
589 0 decoder->intra_dc_precision = 7;
590 0 decoder->frame_pred_frame_dct = 1;
591 0 decoder->concealment_motion_vectors = 0;
592 0 decoder->scan = mpeg2_scan_norm;
593 0 decoder->picture_structure = FRAME_PICTURE;
594 0 mpeg2dec->copy_matrix = 0;
595  
596 0 return 0;
597 }
598  
599 0 static int picture_coding_ext (mpeg2dec_t * mpeg2dec)
600 {
601 0 uint8_t * buffer = mpeg2dec->chunk_start;
602 0 mpeg2_picture_t * picture = &(mpeg2dec->new_picture);
603 0 mpeg2_decoder_t * decoder = &(mpeg2dec->decoder);
604 uint32_t flags;
605  
606 /* pre subtract 1 for use later in compute_motion_vector */
607 0 decoder->f_motion.f_code[0] = (buffer[0] & 15) - 1;
608 0 decoder->f_motion.f_code[1] = (buffer[1] >> 4) - 1;
609 0 decoder->b_motion.f_code[0] = (buffer[1] & 15) - 1;
610 0 decoder->b_motion.f_code[1] = (buffer[2] >> 4) - 1;
611  
612 0 flags = picture->flags;
613 0 decoder->intra_dc_precision = 7 - ((buffer[2] >> 2) & 3);
614 0 decoder->picture_structure = buffer[2] & 3;
615 0 switch (decoder->picture_structure) {
616 0 case TOP_FIELD:
617 0 flags |= PIC_FLAG_TOP_FIELD_FIRST;
618 0 case BOTTOM_FIELD:
619 0 picture->nb_fields = 1;
620 0 break;
621 0 case FRAME_PICTURE:
622 0 ▶ if (!(mpeg2dec->sequence.flags & SEQ_FLAG_PROGRESSIVE_SEQUENCE)) {
Branch: 1 branch
BranchTrueFalseTotal
if (!(mpeg2dec->sequence.flags & SEQ_FLAG_PROGRESSIVE_SEQUENCE)) { 0 0 0
623 0 ▶ picture->nb_fields = (buffer[3] & 2) ? 3 : 2;
Branch: 1 branch
BranchTrueFalseTotal
picture->nb_fields = (buffer[3] & 2) ? 3 : 2; 0 0 0
624 0 flags |= (buffer[3] & 128) ? PIC_FLAG_TOP_FIELD_FIRST : 0;
625 0 flags |= (buffer[3] & 2) ? PIC_FLAG_REPEAT_FIRST_FIELD : 0;
626 } else
627 0 ▶ picture->nb_fields = (buffer[3]&2) ? ((buffer[3]&128) ? 6 : 4) : 2;
Branch: 2 branches
BranchTrueFalseTotal
picture->nb_fields = (buffer[3]&2) ? ((buffer[3]&128) ? 6 : 4) : 2; 0 0 0
picture->nb_fields = (buffer[3]&2) ? ((buffer[3]&128) ? 6 : 4) : 2; 0 0 0
628 0 break;
629 0 default:
630 0 return 1;
631 }
632 0 decoder->top_field_first = buffer[3] >> 7;
633 0 decoder->frame_pred_frame_dct = (buffer[3] >> 6) & 1;
634 0 decoder->concealment_motion_vectors = (buffer[3] >> 5) & 1;
635 0 decoder->q_scale_type = buffer[3] & 16;
636 0 decoder->intra_vlc_format = (buffer[3] >> 3) & 1;
637 0 ▶ decoder->scan = (buffer[3] & 4) ? mpeg2_scan_alt : mpeg2_scan_norm;
Branch: 1 branch
BranchTrueFalseTotal
decoder->scan = (buffer[3] & 4) ? mpeg2_scan_alt : mpeg2_scan_norm; 0 0 0
638 0 ▶ if (!(buffer[4] & 0x80))
Branch: 1 branch
BranchTrueFalseTotal
if (!(buffer[4] & 0x80)) 0 0 0
639 0 flags &= ~PIC_FLAG_PROGRESSIVE_FRAME;
640 0 ▶ if (buffer[4] & 0x40)
Branch: 1 branch
BranchTrueFalseTotal
if (buffer[4] & 0x40) 0 0 0
641 0 flags |= (((buffer[4]<<26) | (buffer[5]<<18) | (buffer[6]<<10)) &
642 PIC_MASK_COMPOSITE_DISPLAY) | PIC_FLAG_COMPOSITE_DISPLAY;
643 0 picture->flags = flags;
644  
645 0 mpeg2dec->ext_state = PIC_DISPLAY_EXT | COPYRIGHT_EXT | QUANT_MATRIX_EXT;
646  
647 0 return 0;
648 }
649  
650 0 static int picture_display_ext (mpeg2dec_t * mpeg2dec)
651 {
652 0 uint8_t * buffer = mpeg2dec->chunk_start;
653 0 mpeg2_picture_t * picture = &(mpeg2dec->new_picture);
654 int i, nb_pos;
655  
656 0 nb_pos = picture->nb_fields;
657 0 ▶ if (mpeg2dec->sequence.flags & SEQ_FLAG_PROGRESSIVE_SEQUENCE)
Branch: 1 branch
BranchTrueFalseTotal
if (mpeg2dec->sequence.flags & SEQ_FLAG_PROGRESSIVE_SEQUENCE) 0 0 0
658 0 nb_pos >>= 1;
659  
660 0 ▶ for (i = 0; i < nb_pos; i++) {
Branch: 1 branch
BranchTrueFalseTotal
for (i = 0; i < nb_pos; i++) { 0 0 0
661 int x, y;
662  
663 0 x = ((buffer[4*i] << 24) | (buffer[4*i+1] << 16) |
664 0 (buffer[4*i+2] << 8) | buffer[4*i+3]) >> (11-2*i);
665 0 y = ((buffer[4*i+2] << 24) | (buffer[4*i+3] << 16) |
666 0 (buffer[4*i+4] << 8) | buffer[4*i+5]) >> (10-2*i);
667 0 ▶ if (! (x & y & 1))
Branch: 1 branch
BranchTrueFalseTotal
if (! (x & y & 1)) 0 0 0
668 0 return 1;
669 0 picture->display_offset[i].x = mpeg2dec->display_offset_x = x >> 1;
670 0 picture->display_offset[i].y = mpeg2dec->display_offset_y = y >> 1;
671 }
672 0 ▶ for (; i < 3; i++) {
Branch: 1 branch
BranchTrueFalseTotal
for (; i < 3; i++) { 0 0 0
673 0 picture->display_offset[i].x = mpeg2dec->display_offset_x;
674 0 picture->display_offset[i].y = mpeg2dec->display_offset_y;
675 }
676 0 return 0;
677 }
678  
679 0 void mpeg2_header_picture_finalize (mpeg2dec_t * mpeg2dec, uint32_t accels)
680 {
681 0 mpeg2_decoder_t * decoder = &(mpeg2dec->decoder);
682 0 int old_type_b = (decoder->coding_type == B_TYPE);
683 0 int low_delay = mpeg2dec->sequence.flags & SEQ_FLAG_LOW_DELAY;
684  
685 0 finalize_matrix (mpeg2dec);
686 0 decoder->coding_type = mpeg2dec->new_picture.flags & PIC_MASK_CODING_TYPE;
687  
688 0 ▶ if (mpeg2dec->state == STATE_PICTURE) {
Branch: 1 branch
BranchTrueFalseTotal
if (mpeg2dec->state == STATE_PICTURE) { 0 0 0
689 mpeg2_picture_t * picture;
690 mpeg2_picture_t * other;
691  
692 0 decoder->second_field = 0;
693  
694 0 picture = other = mpeg2dec->pictures;
695 0 ▶ if (old_type_b ^ (mpeg2dec->picture < mpeg2dec->pictures + 2))
Branch: 1 branch
BranchTrueFalseTotal
if (old_type_b ^ (mpeg2dec->picture < mpeg2dec->pictures + 2)) 0 0 0
696 0 picture += 2;
697 else
698 0 other += 2;
699 0 mpeg2dec->picture = picture;
700 0 *picture = mpeg2dec->new_picture;
701  
702 0 ▶ if (!old_type_b) {
Branch: 1 branch
BranchTrueFalseTotal
if (!old_type_b) { 0 0 0
703 0 mpeg2dec->fbuf[2] = mpeg2dec->fbuf[1];
704 0 mpeg2dec->fbuf[1] = mpeg2dec->fbuf[0];
705 }
706 0 mpeg2dec->fbuf[0] = NULL;
707 0 mpeg2_reset_info (&(mpeg2dec->info));
708 0 mpeg2dec->info.current_picture = picture;
709 0 mpeg2dec->info.display_picture = picture;
710 0 ▶ if (decoder->coding_type != B_TYPE) {
Branch: 1 branch
BranchTrueFalseTotal
if (decoder->coding_type != B_TYPE) { 0 0 0
711 0 ▶ if (!low_delay) {
Branch: 1 branch
BranchTrueFalseTotal
if (!low_delay) { 0 0 0
712 0 ▶ if (mpeg2dec->first) {
Branch: 1 branch
BranchTrueFalseTotal
if (mpeg2dec->first) { 0 0 0
713 0 mpeg2dec->info.display_picture = NULL;
714 0 mpeg2dec->first = 0;
715 } else {
716 0 mpeg2dec->info.display_picture = other;
717 0 ▶ if (other->nb_fields == 1)
Branch: 1 branch
BranchTrueFalseTotal
if (other->nb_fields == 1) 0 0 0
718 0 mpeg2dec->info.display_picture_2nd = other + 1;
719 0 mpeg2dec->info.display_fbuf = mpeg2dec->fbuf[1];
720 }
721 }
722 0 ▶ if (!low_delay + !mpeg2dec->convert)
Branch: 1 branch
BranchTrueFalseTotal
if (!low_delay + !mpeg2dec->convert) 0 0 0
723 0 mpeg2dec->info.discard_fbuf =
724 0 mpeg2dec->fbuf[!low_delay + !mpeg2dec->convert];
725 }
726 0 ▶ if (mpeg2dec->convert) {
Branch: 1 branch
BranchTrueFalseTotal
if (mpeg2dec->convert) { 0 0 0
727 mpeg2_convert_init_t convert_init;
728 0 ▶ if (!mpeg2dec->convert_start) {
Branch: 1 branch
BranchTrueFalseTotal
if (!mpeg2dec->convert_start) { 0 0 0
729 int y_size, uv_size;
730  
731 0 mpeg2dec->decoder.convert_id =
732 0 mpeg2_malloc (mpeg2dec->convert_id_size,
733 MPEG2_ALLOC_CONVERT_ID);
734 0 mpeg2dec->convert (MPEG2_CONVERT_START,
735 mpeg2dec->decoder.convert_id,
736 0 &(mpeg2dec->sequence),
737 mpeg2dec->convert_stride, accels,
738 mpeg2dec->convert_arg, &convert_init);
739 0 mpeg2dec->convert_start = convert_init.start;
740 0 mpeg2dec->decoder.convert = convert_init.copy;
741  
742 0 y_size = decoder->stride_frame * mpeg2dec->sequence.height;
743 0 uv_size = y_size >> (2 - mpeg2dec->decoder.chroma_format);
744 0 mpeg2dec->yuv_buf[0][0] =
745 0 (uint8_t *) mpeg2_malloc (y_size, MPEG2_ALLOC_YUV);
746 0 mpeg2dec->yuv_buf[0][1] =
747 0 (uint8_t *) mpeg2_malloc (uv_size, MPEG2_ALLOC_YUV);
748 0 mpeg2dec->yuv_buf[0][2] =
749 0 (uint8_t *) mpeg2_malloc (uv_size, MPEG2_ALLOC_YUV);
750 0 mpeg2dec->yuv_buf[1][0] =
751 0 (uint8_t *) mpeg2_malloc (y_size, MPEG2_ALLOC_YUV);
752 0 mpeg2dec->yuv_buf[1][1] =
753 0 (uint8_t *) mpeg2_malloc (uv_size, MPEG2_ALLOC_YUV);
754 0 mpeg2dec->yuv_buf[1][2] =
755 0 (uint8_t *) mpeg2_malloc (uv_size, MPEG2_ALLOC_YUV);
756 0 y_size = decoder->stride_frame * 32;
757 0 uv_size = y_size >> (2 - mpeg2dec->decoder.chroma_format);
758 0 mpeg2dec->yuv_buf[2][0] =
759 0 (uint8_t *) mpeg2_malloc (y_size, MPEG2_ALLOC_YUV);
760 0 mpeg2dec->yuv_buf[2][1] =
761 0 (uint8_t *) mpeg2_malloc (uv_size, MPEG2_ALLOC_YUV);
762 0 mpeg2dec->yuv_buf[2][2] =
763 0 (uint8_t *) mpeg2_malloc (uv_size, MPEG2_ALLOC_YUV);
764 }
765 0 ▶ if (!mpeg2dec->custom_fbuf) {
Branch: 1 branch
BranchTrueFalseTotal
if (!mpeg2dec->custom_fbuf) { 0 0 0
766 0 ▶ while (mpeg2dec->alloc_index < 3) {
Branch: 1 branch
BranchTrueFalseTotal
while (mpeg2dec->alloc_index < 3) { 0 0 0
767 mpeg2_fbuf_t * fbuf;
768  
769 0 fbuf = &mpeg2dec->fbuf_alloc[mpeg2dec->alloc_index++].fbuf;
770 0 fbuf->id = NULL;
771 0 fbuf->buf[0] =
772 0 (uint8_t *) mpeg2_malloc (convert_init.buf_size[0],
773 MPEG2_ALLOC_CONVERTED);
774 0 fbuf->buf[1] =
775 0 (uint8_t *) mpeg2_malloc (convert_init.buf_size[1],
776 MPEG2_ALLOC_CONVERTED);
777 0 fbuf->buf[2] =
778 0 (uint8_t *) mpeg2_malloc (convert_init.buf_size[2],
779 MPEG2_ALLOC_CONVERTED);
780 }
781 0 mpeg2_set_fbuf (mpeg2dec, (decoder->coding_type == B_TYPE));
782 }
783 0 ▶ } else if (!mpeg2dec->custom_fbuf) {
Branch: 1 branch
BranchTrueFalseTotal
} else if (!mpeg2dec->custom_fbuf) { 0 0 0
784 0 ▶ while (mpeg2dec->alloc_index < 3) {
Branch: 1 branch
BranchTrueFalseTotal
while (mpeg2dec->alloc_index < 3) { 0 0 0
785 mpeg2_fbuf_t * fbuf;
786 int y_size, uv_size;
787  
788 0 fbuf = &(mpeg2dec->fbuf_alloc[mpeg2dec->alloc_index++].fbuf);
789 0 fbuf->id = NULL;
790 0 y_size = decoder->stride_frame * mpeg2dec->sequence.height;
791 0 uv_size = y_size >> (2 - decoder->chroma_format);
792 0 fbuf->buf[0] = (uint8_t *) mpeg2_malloc (y_size,
793 MPEG2_ALLOC_YUV);
794 0 fbuf->buf[1] = (uint8_t *) mpeg2_malloc (uv_size,
795 MPEG2_ALLOC_YUV);
796 0 fbuf->buf[2] = (uint8_t *) mpeg2_malloc (uv_size,
797 MPEG2_ALLOC_YUV);
798 }
799 0 mpeg2_set_fbuf (mpeg2dec, (decoder->coding_type == B_TYPE));
800 }
801 } else {
802 0 decoder->second_field = 1;
803 0 mpeg2dec->picture++; /* second field picture */
804 0 *(mpeg2dec->picture) = mpeg2dec->new_picture;
805 0 mpeg2dec->info.current_picture_2nd = mpeg2dec->picture;
806 0 ▶ if (low_delay || decoder->coding_type == B_TYPE)
Branch: 2 branches
BranchTrueFalseTotal
if (low_delay || decoder->coding_type == B_TYPE) 0 0 0
if (low_delay || decoder->coding_type == B_TYPE) 0 0 0
807 0 mpeg2dec->info.display_picture_2nd = mpeg2dec->picture;
808 }
809  
810 0 info_user_data (mpeg2dec);
811 0 }
812  
813 0 static int copyright_ext (mpeg2dec_t * mpeg2dec)
814 {
815 0 return 0;
816 }
817  
818 0 static int quant_matrix_ext (mpeg2dec_t * mpeg2dec)
819 {
820 0 uint8_t * buffer = mpeg2dec->chunk_start;
821 int i, j;
822  
823 0 ▶ for (i = 0; i < 4; i++)
Branch: 1 branch
BranchTrueFalseTotal
for (i = 0; i < 4; i++) 0 0 0
824 0 ▶ if (buffer[0] & (8 >> i)) {
Branch: 1 branch
BranchTrueFalseTotal
if (buffer[0] & (8 >> i)) { 0 0 0
825 0 ▶ for (j = 0; j < 64; j++)
Branch: 1 branch
BranchTrueFalseTotal
for (j = 0; j < 64; j++) 0 0 0
826 0 mpeg2dec->new_quantizer_matrix[i][mpeg2_scan_norm[j]] =
827 0 (buffer[j] << (i+5)) | (buffer[j+1] >> (3-i));
828 0 mpeg2dec->copy_matrix |= 1 << i;
829 0 buffer += 64;
830 }
831  
832 0 return 0;
833 }
834  
835 0 int mpeg2_header_extension (mpeg2dec_t * mpeg2dec)
836 {
837 static int (* parser[]) (mpeg2dec_t *) = {
838 0, sequence_ext, sequence_display_ext, quant_matrix_ext,
839 copyright_ext, 0, 0, picture_display_ext, picture_coding_ext
840 };
841 int ext, ext_bit;
842  
843 0 ext = mpeg2dec->chunk_start[0] >> 4;
844 0 ext_bit = 1 << ext;
845  
846 0 ▶ if (!(mpeg2dec->ext_state & ext_bit))
Branch: 1 branch
BranchTrueFalseTotal
if (!(mpeg2dec->ext_state & ext_bit)) 0 0 0
847 0 return 0; /* ignore illegal extensions */
848 0 mpeg2dec->ext_state &= ~ext_bit;
849 0 return parser[ext] (mpeg2dec);
850 }
851  
852 0 int mpeg2_header_user_data (mpeg2dec_t * mpeg2dec)
853 {
854 0 mpeg2dec->user_data_len += mpeg2dec->chunk_ptr - 1 - mpeg2dec->chunk_start;
855 0 mpeg2dec->chunk_start = mpeg2dec->chunk_ptr - 1;
856
857 0 return 0;
858 }
859  
860 0 static void prescale (mpeg2dec_t * mpeg2dec, int idx)
861 {
862 static int non_linear_scale [] = {
863 0, 1, 2, 3, 4, 5, 6, 7,
864 8, 10, 12, 14, 16, 18, 20, 22,
865 24, 28, 32, 36, 40, 44, 48, 52,
866 56, 64, 72, 80, 88, 96, 104, 112
867 };
868 int i, j, k;
869 0 mpeg2_decoder_t * decoder = &(mpeg2dec->decoder);
870  
871 0 ▶ if (mpeg2dec->scaled[idx] != decoder->q_scale_type) {
Branch: 1 branch
BranchTrueFalseTotal
if (mpeg2dec->scaled[idx] != decoder->q_scale_type) { 0 0 0
872 0 mpeg2dec->scaled[idx] = decoder->q_scale_type;
873 0 ▶ for (i = 0; i < 32; i++) {
Branch: 1 branch
BranchTrueFalseTotal
for (i = 0; i < 32; i++) { 0 0 0
874 0 ▶ k = decoder->q_scale_type ? non_linear_scale[i] : (i << 1);
Branch: 1 branch
BranchTrueFalseTotal
k = decoder->q_scale_type ? non_linear_scale[i] : (i << 1); 0 0 0
875 0 ▶ for (j = 0; j < 64; j++)
Branch: 1 branch
BranchTrueFalseTotal
for (j = 0; j < 64; j++) 0 0 0
876 0 decoder->quantizer_prescale[idx][i][j] =
877 0 k * mpeg2dec->quantizer_matrix[idx][j];
878 }
879 }
880 0 }
881  
882 0 mpeg2_state_t mpeg2_header_slice_start (mpeg2dec_t * mpeg2dec)
883 {
884 0 mpeg2_decoder_t * decoder = &(mpeg2dec->decoder);
885  
886 0 mpeg2dec->info.user_data = NULL; mpeg2dec->info.user_data_len = 0;
887 0 mpeg2dec->state = ((mpeg2dec->picture->nb_fields > 1 ||
888 0 ▶ mpeg2dec->state == STATE_PICTURE_2ND) ?
Branch: 1 branch
BranchTrueFalseTotal
mpeg2dec->state == STATE_PICTURE_2ND) ? 0 0 0
889 0 ▶ STATE_SLICE : STATE_SLICE_1ST);
Branch: 1 branch
BranchTrueFalseTotal
STATE_SLICE : STATE_SLICE_1ST); 0 0 0
890  
891 0 ▶ if (mpeg2dec->decoder.coding_type != D_TYPE) {
Branch: 1 branch
BranchTrueFalseTotal
if (mpeg2dec->decoder.coding_type != D_TYPE) { 0 0 0
892 0 prescale (mpeg2dec, 0);
893 0 ▶ if (decoder->chroma_quantizer[0] == decoder->quantizer_prescale[2])
Branch: 1 branch
BranchTrueFalseTotal
if (decoder->chroma_quantizer[0] == decoder->quantizer_prescale[2]) 0 0 0
894 0 prescale (mpeg2dec, 2);
895 0 ▶ if (mpeg2dec->decoder.coding_type != I_TYPE) {
Branch: 1 branch
BranchTrueFalseTotal
if (mpeg2dec->decoder.coding_type != I_TYPE) { 0 0 0
896 0 prescale (mpeg2dec, 1);
897 0 ▶ if (decoder->chroma_quantizer[1] == decoder->quantizer_prescale[3])
Branch: 1 branch
BranchTrueFalseTotal
if (decoder->chroma_quantizer[1] == decoder->quantizer_prescale[3]) 0 0 0
898 0 prescale (mpeg2dec, 3);
899 }
900 }
901  
902 0 ▶ if (!(mpeg2dec->nb_decode_slices))
Branch: 1 branch
BranchTrueFalseTotal
if (!(mpeg2dec->nb_decode_slices)) 0 0 0
903 0 mpeg2dec->picture->flags |= PIC_FLAG_SKIP;
904 0 ▶ else if (mpeg2dec->convert_start) {
Branch: 1 branch
BranchTrueFalseTotal
else if (mpeg2dec->convert_start) { 0 0 0
905 0 mpeg2dec->convert_start (decoder->convert_id, mpeg2dec->fbuf[0],
906 0 mpeg2dec->picture, mpeg2dec->info.gop);
907  
908 0 ▶ if (mpeg2dec->decoder.coding_type == B_TYPE)
Branch: 1 branch
BranchTrueFalseTotal
if (mpeg2dec->decoder.coding_type == B_TYPE) 0 0 0
909 0 mpeg2_init_fbuf (&(mpeg2dec->decoder), mpeg2dec->yuv_buf[2],
910 0 mpeg2dec->yuv_buf[mpeg2dec->yuv_index ^ 1],
911 0 mpeg2dec->yuv_buf[mpeg2dec->yuv_index]);
912 else {
913 0 mpeg2_init_fbuf (&(mpeg2dec->decoder),
914 0 mpeg2dec->yuv_buf[mpeg2dec->yuv_index ^ 1],
915 0 mpeg2dec->yuv_buf[mpeg2dec->yuv_index],
916 0 mpeg2dec->yuv_buf[mpeg2dec->yuv_index]);
917 0 ▶ if (mpeg2dec->state == STATE_SLICE)
Branch: 1 branch
BranchTrueFalseTotal
if (mpeg2dec->state == STATE_SLICE) 0 0 0
918 0 mpeg2dec->yuv_index ^= 1;
919 }
920 } else {
921 int b_type;
922  
923 0 b_type = (mpeg2dec->decoder.coding_type == B_TYPE);
924 0 mpeg2_init_fbuf (&(mpeg2dec->decoder), mpeg2dec->fbuf[0]->buf,
925 0 mpeg2dec->fbuf[b_type + 1]->buf,
926 0 mpeg2dec->fbuf[b_type]->buf);
927 }
928 0 mpeg2dec->action = NULL;
929 0 return STATE_INTERNAL_NORETURN;
930 }
931  
932 0 static mpeg2_state_t seek_sequence (mpeg2dec_t * mpeg2dec)
933 {
934 0 mpeg2_reset_info (&(mpeg2dec->info));
935 0 mpeg2dec->info.sequence = NULL;
936 0 mpeg2dec->info.gop = NULL;
937 0 mpeg2_header_state_init (mpeg2dec);
938 0 mpeg2dec->action = mpeg2_seek_header;
939 0 return mpeg2_seek_header (mpeg2dec);
940 }
941  
942 0 mpeg2_state_t mpeg2_header_end (mpeg2dec_t * mpeg2dec)
943 {
944 mpeg2_picture_t * picture;
945 int b_type;
946  
947 0 b_type = (mpeg2dec->decoder.coding_type == B_TYPE);
948 0 picture = mpeg2dec->pictures;
949 0 ▶ if ((mpeg2dec->picture >= picture + 2) ^ b_type)
Branch: 1 branch
BranchTrueFalseTotal
if ((mpeg2dec->picture >= picture + 2) ^ b_type) 0 0 0
950 0 picture = mpeg2dec->pictures + 2;
951  
952 0 mpeg2_reset_info (&(mpeg2dec->info));
953 0 ▶ if (!(mpeg2dec->sequence.flags & SEQ_FLAG_LOW_DELAY)) {
Branch: 1 branch
BranchTrueFalseTotal
if (!(mpeg2dec->sequence.flags & SEQ_FLAG_LOW_DELAY)) { 0 0 0
954 0 mpeg2dec->info.display_picture = picture;
955 0 ▶ if (picture->nb_fields == 1)
Branch: 1 branch
BranchTrueFalseTotal
if (picture->nb_fields == 1) 0 0 0
956 0 mpeg2dec->info.display_picture_2nd = picture + 1;
957 0 mpeg2dec->info.display_fbuf = mpeg2dec->fbuf[b_type];
958 0 ▶ if (!mpeg2dec->convert)
Branch: 1 branch
BranchTrueFalseTotal
if (!mpeg2dec->convert) 0 0 0
959 0 mpeg2dec->info.discard_fbuf = mpeg2dec->fbuf[b_type + 1];
960 0 ▶ } else if (!mpeg2dec->convert)
Branch: 1 branch
BranchTrueFalseTotal
} else if (!mpeg2dec->convert) 0 0 0
961 0 mpeg2dec->info.discard_fbuf = mpeg2dec->fbuf[b_type];
962 0 mpeg2dec->action = seek_sequence;
963 0 return STATE_END;
964 }
« clib/libmpeg2/decode.c ↑ Summary clib/libmpeg2/idct.c »