Details | Last modification | View Log | RSS feed
Rev | Author | Line No. | Line |
---|---|---|---|
1085 | pj | 1 | /* #define DEBUG */ |
2 | /* subspic.c, Frame buffer substitution routines */ |
||
3 | |||
4 | /* Copyright (C) 1996, MPEG Software Simulation Group. All Rights Reserved. */ |
||
5 | |||
6 | /* |
||
7 | * Disclaimer of Warranty |
||
8 | * |
||
9 | * These software programs are available to the user without any license fee or |
||
10 | * royalty on an "as is" basis. The MPEG Software Simulation Group disclaims |
||
11 | * any and all warranties, whether express, implied, or statuary, including any |
||
12 | * implied warranties or merchantability or of fitness for a particular |
||
13 | * purpose. In no event shall the copyright-holder be liable for any |
||
14 | * incidental, punitive, or consequential damages of any kind whatsoever |
||
15 | * arising from the use of these programs. |
||
16 | * |
||
17 | * This disclaimer of warranty extends to the user of these programs and user's |
||
18 | * customers, employees, agents, transferees, successors, and assigns. |
||
19 | * |
||
20 | * The MPEG Software Simulation Group does not represent or warrant that the |
||
21 | * programs furnished hereunder are free of infringement of any third-party |
||
22 | * patents. |
||
23 | * |
||
24 | * Commercial implementations of MPEG-1 and MPEG-2 video, including shareware, |
||
25 | * are subject to royalty fees to patent holders. Many of these patents are |
||
26 | * general enough such that they are unavoidable regardless of implementation |
||
27 | * design. |
||
28 | * |
||
29 | */ |
||
30 | |||
31 | #include <stdio.h> |
||
32 | #include <stdlib.h> |
||
33 | #include <fcntl.h> |
||
34 | |||
35 | #include "config.h" |
||
36 | #include "global.h" |
||
37 | |||
38 | /* private prototypes*/ |
||
39 | static void Read_Frame _ANSI_ARGS_((char *filename, |
||
40 | unsigned char *frame_buffer[], int framenum)); |
||
41 | static void Copy_Frame _ANSI_ARGS_((unsigned char *src, unsigned char *dst, |
||
42 | int width, int height, int parity, int incr)); |
||
43 | static int Read_Components _ANSI_ARGS_ ((char *filename, |
||
44 | unsigned char *frame[3], int framenum)); |
||
45 | static int Read_Component _ANSI_ARGS_ ((char *fname, unsigned char *frame, |
||
46 | int width, int height)); |
||
47 | static int Extract_Components _ANSI_ARGS_ ((char *filename, |
||
48 | unsigned char *frame[3], int framenum)); |
||
49 | |||
50 | |||
51 | /* substitute frame buffer routine */ |
||
52 | void Substitute_Frame_Buffer (bitstream_framenum, sequence_framenum) |
||
53 | int bitstream_framenum; |
||
54 | int sequence_framenum; |
||
55 | { |
||
56 | /* static tracking variables */ |
||
57 | static int previous_temporal_reference; |
||
58 | static int previous_bitstream_framenum; |
||
59 | static int previous_anchor_temporal_reference; |
||
60 | static int previous_anchor_bitstream_framenum; |
||
61 | static int previous_picture_coding_type; |
||
62 | static int bgate; |
||
63 | |||
64 | /* local temporary variables */ |
||
65 | int substitute_display_framenum; |
||
66 | |||
67 | |||
68 | #ifdef DEBUG |
||
69 | printf("SUB: seq fn(%d) bitfn(%d) tempref(%d) picstr(%d) type(%d)\n", |
||
70 | sequence_framenum, bitstream_framenum, temporal_reference, |
||
71 | picture_structure, picture_coding_type); |
||
72 | #endif |
||
73 | |||
74 | /* we don't substitute at the first picture of a sequence */ |
||
75 | if((sequence_framenum!=0)||(Second_Field)) |
||
76 | { |
||
77 | /* only at the start of the frame */ |
||
78 | if ((picture_structure==FRAME_PICTURE)||(!Second_Field)) |
||
79 | { |
||
80 | if(picture_coding_type==P_TYPE) |
||
81 | { |
||
82 | /* the most recently decoded reference frame needs substituting */ |
||
83 | substitute_display_framenum = bitstream_framenum - 1; |
||
84 | |||
85 | Read_Frame(Substitute_Picture_Filename, forward_reference_frame, |
||
86 | substitute_display_framenum); |
||
87 | } |
||
88 | /* only the first B frame in a consequitve set of B pictures |
||
89 | loads a substitute backward_reference_frame since all subsequent |
||
90 | B frames predict from the same reference pictures */ |
||
91 | else if((picture_coding_type==B_TYPE)&&(bgate!=1)) |
||
92 | { |
||
93 | substitute_display_framenum = |
||
94 | (previous_temporal_reference - temporal_reference) |
||
95 | + bitstream_framenum - 1; |
||
96 | |||
97 | Read_Frame(Substitute_Picture_Filename, backward_reference_frame, |
||
98 | substitute_display_framenum); |
||
99 | } |
||
100 | } /* P fields can predict from the two most recently decoded fields, even |
||
101 | from the first field of the same frame being decoded */ |
||
102 | else if(Second_Field && (picture_coding_type==P_TYPE)) |
||
103 | { |
||
104 | /* our favourite case: the IP field picture pair */ |
||
105 | if((previous_picture_coding_type==I_TYPE)&&(picture_coding_type==P_TYPE)) |
||
106 | { |
||
107 | substitute_display_framenum = bitstream_framenum; |
||
108 | } |
||
109 | else /* our more generic P field picture pair */ |
||
110 | { |
||
111 | substitute_display_framenum = |
||
112 | (temporal_reference - previous_anchor_temporal_reference) |
||
113 | + bitstream_framenum - 1; |
||
114 | } |
||
115 | |||
116 | Read_Frame(Substitute_Picture_Filename, current_frame, substitute_display_framenum); |
||
117 | } |
||
118 | #ifdef DEBUG |
||
119 | else if((picture_coding_type!=B_TYPE)||(picture_coding_type!=D_TYPE)) |
||
120 | { |
||
121 | printf("NO SUBS FOR THIS PICTURE\n"); |
||
122 | } |
||
123 | #endif |
||
124 | } |
||
125 | |||
126 | |||
127 | /* set b gate so we don't redundantly load next time around */ |
||
128 | if(picture_coding_type==B_TYPE) |
||
129 | bgate = 1; |
||
130 | else |
||
131 | bgate = 0; |
||
132 | |||
133 | /* update general tracking variables */ |
||
134 | if((picture_structure==FRAME_PICTURE)||(!Second_Field)) |
||
135 | { |
||
136 | previous_temporal_reference = temporal_reference; |
||
137 | previous_bitstream_framenum = bitstream_framenum; |
||
138 | } |
||
139 | |||
140 | /* update reference frame tracking variables */ |
||
141 | if((picture_coding_type!=B_TYPE) && |
||
142 | ((picture_structure==FRAME_PICTURE)||Second_Field)) |
||
143 | { |
||
144 | previous_anchor_temporal_reference = temporal_reference; |
||
145 | previous_anchor_bitstream_framenum = bitstream_framenum; |
||
146 | } |
||
147 | |||
148 | previous_picture_coding_type = picture_coding_type; |
||
149 | |||
150 | } |
||
151 | |||
152 | |||
153 | /* Note: fields are only read to serve as the same-frame reference for |
||
154 | a second field */ |
||
155 | static void Read_Frame(fname,frame,framenum) |
||
156 | char *fname; |
||
157 | unsigned char *frame[]; |
||
158 | int framenum; |
||
159 | { |
||
160 | int parity; |
||
161 | int rerr = 0; |
||
162 | int field_mode; |
||
163 | |||
164 | if(framenum<0) |
||
165 | printf("ERROR: framenum (%d) is less than zero\n", framenum); |
||
166 | |||
167 | |||
168 | if(Big_Picture_Flag) |
||
169 | rerr = Extract_Components(fname, substitute_frame, framenum); |
||
170 | else |
||
171 | rerr = Read_Components(fname, substitute_frame, framenum); |
||
172 | |||
173 | if(rerr!=0) |
||
174 | { |
||
175 | printf("was unable to substitute frame\n"); |
||
176 | } |
||
177 | |||
178 | /* now copy to the appropriate buffer */ |
||
179 | /* first field (which we are attempting to substitute) must be |
||
180 | of opposite field parity to the current one */ |
||
181 | if((Second_Field)&&(picture_coding_type==P_TYPE)) |
||
182 | { |
||
183 | parity = (picture_structure==TOP_FIELD ? 1:0); |
||
184 | field_mode = (picture_structure==FRAME_PICTURE ? 0:1); |
||
185 | } |
||
186 | else |
||
187 | { |
||
188 | /* Like frame structued pictures, B pictures only substitute an entire frame |
||
189 | since both fields always predict from the same frame (with respect |
||
190 | to forward/backwards directions) */ |
||
191 | parity = 0; |
||
192 | field_mode = 0; |
||
193 | } |
||
194 | |||
195 | |||
196 | Copy_Frame(substitute_frame[0], frame[0], Coded_Picture_Width, |
||
197 | Coded_Picture_Height, parity, field_mode); |
||
198 | |||
199 | Copy_Frame(substitute_frame[1], frame[1], Chroma_Width, Chroma_Height, |
||
200 | parity, field_mode); |
||
201 | |||
202 | Copy_Frame(substitute_frame[2], frame[2], Chroma_Width, Chroma_Height, |
||
203 | parity, field_mode); |
||
204 | |||
205 | #ifdef VERBOSE |
||
206 | if(Verbose_Flag > NO_LAYER) |
||
207 | printf("substituted %s %d\n", |
||
208 | (field_mode ? (parity?"bottom field":"bottom field"):"frame"), framenum); |
||
209 | #endif |
||
210 | } |
||
211 | |||
212 | |||
213 | |||
214 | |||
215 | static int Read_Components(filename, frame, framenum) |
||
216 | char *filename; |
||
217 | unsigned char *frame[3]; |
||
218 | int framenum; |
||
219 | { |
||
220 | int err = 0; |
||
221 | char outname[FILENAME_LENGTH]; |
||
222 | char name[FILENAME_LENGTH]; |
||
223 | |||
224 | sprintf(outname,filename,framenum); |
||
225 | |||
226 | |||
227 | sprintf(name,"%s.Y",outname); |
||
228 | err += Read_Component(name, frame[0], Coded_Picture_Width, |
||
229 | Coded_Picture_Height); |
||
230 | |||
231 | sprintf(name,"%s.U",outname); |
||
232 | err += Read_Component(name, frame[1], Chroma_Width, Chroma_Height); |
||
233 | |||
234 | sprintf(name,"%s.V",outname); |
||
235 | err += Read_Component(name, frame[2], Chroma_Width, Chroma_Height); |
||
236 | |||
237 | return(err); |
||
238 | } |
||
239 | |||
240 | |||
241 | static int Read_Component(Filename, Frame, Width, Height) |
||
242 | char *Filename; |
||
243 | unsigned char *Frame; |
||
244 | int Width; |
||
245 | int Height; |
||
246 | { |
||
247 | int Size; |
||
248 | int Bytes_Read; |
||
249 | int Infile; |
||
250 | |||
251 | Size = Width*Height; |
||
252 | |||
253 | #ifdef DEBUG |
||
254 | printf("SUBS: reading %s\n", filename); |
||
255 | #endif |
||
256 | |||
257 | if(!(Infile=open(Filename,O_RDONLY|O_BINARY))<0) |
||
258 | { |
||
259 | printf("ERROR: unable to open reference filename (%s)\n", Filename); |
||
260 | return(-1); |
||
261 | } |
||
262 | |||
263 | Bytes_Read = read(Infile, Frame, Size); |
||
264 | |||
265 | if(Bytes_Read!=Size) |
||
266 | { |
||
267 | printf("was able to read only %d bytes of %d of file %s\n", |
||
268 | Bytes_Read, Size, Filename); |
||
269 | } |
||
270 | |||
271 | close(Infile); |
||
272 | return(0); |
||
273 | } |
||
274 | |||
275 | |||
276 | /* optimization: do not open the big file each time. Open once at start |
||
277 | of decoder, and close at the very last frame */ |
||
278 | |||
279 | /* Note: "big" files were used in E-mail exchanges almost exclusively by the |
||
280 | MPEG Committee's syntax validation and conformance ad-hoc groups from |
||
281 | the year 1993 until 1995 */ |
||
282 | static int Extract_Components(filename, frame, framenum) |
||
283 | char *filename; |
||
284 | unsigned char *frame[3]; |
||
285 | int framenum; |
||
286 | { |
||
287 | /* int err = 0; */ |
||
288 | FILE *fd; |
||
289 | int line; |
||
290 | int size, offset; |
||
291 | |||
292 | |||
293 | if (!(fd = fopen(filename,"rb"))) |
||
294 | { |
||
295 | sprintf(Error_Text,"Couldn't open %s\n",filename); |
||
296 | return(-1); |
||
297 | } |
||
298 | |||
299 | /* compute size of each frame (in bytes) */ |
||
300 | size = (Coded_Picture_Width*Coded_Picture_Height); |
||
301 | |||
302 | if(chroma_format==CHROMA444) |
||
303 | size = (size * 3); |
||
304 | else if(chroma_format==CHROMA422) |
||
305 | size = (size * 2); |
||
306 | else if(chroma_format==CHROMA420) |
||
307 | size = ((size*3)>>1); |
||
308 | else |
||
309 | printf("ERROR: chroma_format (%d) not recognized\n", chroma_format); |
||
310 | |||
311 | |||
312 | /* compute distance into "big" file */ |
||
313 | offset = size*framenum; |
||
314 | |||
315 | #ifdef DEBUG |
||
316 | printf("EXTRACTING: frame(%d) offset(%d), size (%d) from %s\n", |
||
317 | framenum, offset, size, filename); |
||
318 | #endif |
||
319 | |||
320 | /* seek to location in big file where desired frame begins */ |
||
321 | /* note: this offset cannot exceed a few billion bytes due to the */ |
||
322 | /* obvious limitations of 32-bit integers */ |
||
323 | fseek(fd, offset, 0); |
||
324 | |||
325 | /* Y */ |
||
326 | for (line=0; line<Coded_Picture_Height; line++) |
||
327 | { |
||
328 | fread(frame[0]+(line*Coded_Picture_Width),1,Coded_Picture_Width,fd); |
||
329 | } |
||
330 | |||
331 | /* Cb */ |
||
332 | for (line=0; line<Chroma_Height; line++) |
||
333 | { |
||
334 | fread(frame[1]+(line*Chroma_Width),1,Chroma_Width,fd); |
||
335 | } |
||
336 | |||
337 | /* Cr */ |
||
338 | for (line=0; line<Chroma_Height; line++) |
||
339 | { |
||
340 | fread(frame[2]+(line*Chroma_Width),1,Chroma_Width,fd); |
||
341 | } |
||
342 | |||
343 | |||
344 | fclose(fd); |
||
345 | return(0); |
||
346 | } |
||
347 | |||
348 | |||
349 | static void Copy_Frame(src, dst, width, height, parity, field_mode) |
||
350 | unsigned char *src; |
||
351 | unsigned char *dst; |
||
352 | int width; |
||
353 | int height; |
||
354 | int parity; /* field parity (top or bottom) to overwrite */ |
||
355 | int field_mode; /* 0 = frame, 1 = field */ |
||
356 | { |
||
357 | int row, col; |
||
358 | int s, d; |
||
359 | int incr; |
||
360 | |||
361 | s = d = 0; |
||
362 | |||
363 | #ifdef DEBUG |
||
364 | printf("COPYING (w=%d, h=%d, parity=%d, field_mode=%d)\n", |
||
365 | width,height,parity,field_mode); |
||
366 | #endif /* DEBUG */ |
||
367 | |||
368 | if(field_mode) |
||
369 | { |
||
370 | incr = 2; |
||
371 | |||
372 | if(parity==0) |
||
373 | s += width; |
||
374 | } |
||
375 | else |
||
376 | { |
||
377 | incr = 1; |
||
378 | } |
||
379 | |||
380 | for(row=0; row<height; row+=incr) |
||
381 | { |
||
382 | for(col=0; col<width; col++) |
||
383 | { |
||
384 | dst[d+col] = src[s+col]; |
||
385 | } |
||
386 | |||
387 | d += (width*incr); |
||
388 | s += (width*incr); |
||
389 | } |
||
390 | |||
391 | } |
||
392 |