]> Creatis software - gdcm.git/blob - gdcmMpeg.cxx
516f1bbaccea6017189379b4e6a52119d494e252
[gdcm.git] / gdcmMpeg.cxx
1 /*=========================================================================
2                                                                                 
3   Program:   gdcm
4   Module:    $RCSfile: gdcmMpeg.cxx,v $
5   Language:  C++
6   Date:      $Date: 2005/06/24 10:55:59 $
7   Version:   $Revision: 1.5 $
8                                                                                 
9   Copyright (c) CREATIS (Centre de Recherche et d'Applications en Traitement de
10   l'Image). All rights reserved. See Doc/License.txt or
11   http://www.creatis.insa-lyon.fr/Public/Gdcm/License.html for details.
12                                                                                 
13      This software is distributed WITHOUT ANY WARRANTY; without even
14      the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
15      PURPOSE.  See the above copyright notices for more information.
16                                                                                 
17 =========================================================================*/
18 #include "gdcmDebug.h"
19
20 #include <fstream>
21 #include <stdio.h>
22 #include <stdlib.h>
23 #include <ctype.h>
24 #include <fcntl.h>
25 extern "C" {
26 #define GLOBAL
27 #include "config.h"
28 #include "global.h"
29
30 /* private prototypes */
31 static int  video_sequence        _ANSI_ARGS_((int *framenum));
32 static int  Decode_Bitstream      _ANSI_ARGS_((void));
33 static int  Headers               _ANSI_ARGS_((void));
34 static void Initialize_Sequence   _ANSI_ARGS_((void));
35 static void Initialize_Decoder    _ANSI_ARGS_((void));
36 static void Deinitialize_Sequence _ANSI_ARGS_((void));
37 //static void Process_Options       _ANSI_ARGS_((int argc, char *argv[]));
38
39 /* IMPLEMENTATION specific routines */
40 static void Initialize_Decoder()
41 {
42   int i;
43
44   /* Clip table */
45   if ( !(Clip=(unsigned char *)malloc(1024)) )
46     Error("Clip[] malloc failed\n");
47
48   Clip += 384;
49
50   for (i=-384; i<640; i++)
51     Clip[i] = (i<0) ? 0 : ((i>255) ? 255 : i);
52
53   /* IDCT */
54   if ( Reference_IDCT_Flag )
55     Initialize_Reference_IDCT();
56   else
57     Initialize_Fast_IDCT();
58
59 }
60
61 /* mostly IMPLEMENTATION specific routines */
62 static void Initialize_Sequence()
63 {
64   int cc, size;
65   static int Table_6_20[3] = {6,8,12};
66
67   /* check scalability mode of enhancement layer */
68   if ( Two_Streams && (enhan.scalable_mode!=SC_SNR) 
69       &&
70        (base.scalable_mode!=SC_DP) )
71   {
72      Error("unsupported scalability mode\n");
73   }
74   /* force MPEG-1 parameters for proper decoder behavior */
75   /* see ISO/IEC 13818-2 section D.9.14 */
76   if ( !base.MPEG2_Flag )
77   {
78     progressive_sequence = 1;
79     progressive_frame = 1;
80     picture_structure = FRAME_PICTURE;
81     frame_pred_frame_dct = 1;
82     chroma_format = CHROMA420;
83     matrix_coefficients = 5;
84   }
85
86   /* round to nearest multiple of coded macroblocks */
87   /* ISO/IEC 13818-2 section 6.3.3 sequence_header() */
88   mb_width = (horizontal_size+15)/16;
89   mb_height = (base.MPEG2_Flag && !progressive_sequence) ? 2*((vertical_size+31)/32)
90                                         : (vertical_size+15)/16;
91
92   Coded_Picture_Width = 16*mb_width;
93   Coded_Picture_Height = 16*mb_height;
94
95   /* ISO/IEC 13818-2 sections 6.1.1.8, 6.1.1.9, and 6.1.1.10 */
96   Chroma_Width = (chroma_format==CHROMA444) ? Coded_Picture_Width
97                                            : Coded_Picture_Width>>1;
98   Chroma_Height = (chroma_format!=CHROMA420) ? Coded_Picture_Height
99                                             : Coded_Picture_Height>>1;
100   
101   /* derived based on Table 6-20 in ISO/IEC 13818-2 section 6.3.17 */
102   block_count = Table_6_20[chroma_format-1];
103
104   for (cc=0; cc<3; cc++)
105   {
106     if ( cc==0 )
107       size = Coded_Picture_Width*Coded_Picture_Height;
108     else
109       size = Chroma_Width*Chroma_Height;
110
111     if ( !(backward_reference_frame[cc] = (unsigned char *)malloc(size)) )
112       Error("backward_reference_frame[] malloc failed\n");
113
114     if ( !(forward_reference_frame[cc] = (unsigned char *)malloc(size)) )
115       Error("forward_reference_frame[] malloc failed\n");
116
117     if ( !(auxframe[cc] = (unsigned char *)malloc(size)) )
118       Error("auxframe[] malloc failed\n");
119
120     if (  Ersatz_Flag )
121       if ( !(substitute_frame[cc] = (unsigned char *)malloc(size)) )
122         Error("substitute_frame[] malloc failed\n");
123
124
125     if ( base.scalable_mode==SC_SPAT )
126     {
127       /* this assumes lower layer is 4:2:0 */
128       if ( !(llframe0[cc] = (unsigned char *)malloc((lower_layer_prediction_horizontal_size*lower_layer_prediction_vertical_size)/(cc?4:1))))
129         Error("llframe0 malloc failed\n");
130       if ( !(llframe1[cc] = (unsigned char *)malloc((lower_layer_prediction_horizontal_size*lower_layer_prediction_vertical_size)/(cc?4:1))))
131         Error("llframe1 malloc failed\n");
132     }
133   }
134
135   /* SCALABILITY: Spatial */
136   if ( base.scalable_mode==SC_SPAT )
137   {
138     if ( !(lltmp = (short *)malloc(lower_layer_prediction_horizontal_size*((lower_layer_prediction_vertical_size*vertical_subsampling_factor_n)/vertical_subsampling_factor_m)*sizeof(short))))
139       Error("lltmp malloc failed\n");
140   }
141
142 #ifdef DISPLAY
143   if (Output_Type==T_X11)
144   {
145     Initialize_Display_Process("");
146     Initialize_Dither_Matrix();
147   }
148 #endif /* DISPLAY */
149
150 }
151
152 extern void Error(char *text)
153 {
154   fprintf(stderr,text);
155   exit(1);
156 }
157
158 /* Trace_Flag output */
159 void Print_Bits(int code, int bits, int len)
160 {
161   int i;
162   for (i=0; i<len; i++)
163     printf("%d",(code>>(bits-1-i))&1);
164 }
165
166 static int Headers()
167 {
168   int ret;
169
170   ld = &base;
171   
172   /* return when end of sequence (0) or picture
173      header has been parsed (1) */
174
175   ret = Get_Hdr();
176
177
178   if (Two_Streams)
179   {
180     ld = &enhan;
181     if (Get_Hdr()!=ret && !Quiet_Flag)
182       fprintf(stderr,"streams out of sync\n");
183     ld = &base;
184   }
185
186   return ret;
187 }
188
189
190
191 static int Decode_Bitstream()
192 {
193   int ret;
194   int Bitstream_Framenum;
195
196   Bitstream_Framenum = 0;
197
198   for(;;)
199   {
200
201 #ifdef VERIFY
202     Clear_Verify_Headers();
203 #endif /* VERIFY */
204
205     ret = Headers();
206     
207     if ( ret==1 )
208     {
209       ret = video_sequence(&Bitstream_Framenum);
210     }
211     else
212       return(ret);
213   }
214
215 }
216
217
218 static void Deinitialize_Sequence()
219 {
220   int i;
221
222   /* clear flags */
223   base.MPEG2_Flag=0;
224
225   for(i=0;i<3;i++)
226   {
227     free(backward_reference_frame[i]);
228     free(forward_reference_frame[i]);
229     free(auxframe[i]);
230
231     if ( base.scalable_mode==SC_SPAT )
232     {
233      free(llframe0[i]);
234      free(llframe1[i]);
235     }
236   }
237
238   if ( base.scalable_mode==SC_SPAT )
239     free(lltmp);
240
241 #ifdef DISPLAY
242   if ( Output_Type==T_X11 ) 
243     Terminate_Display_Process();
244 #endif
245 }
246
247
248 static int video_sequence(int *Bitstream_Framenumber)
249 {
250   int Bitstream_Framenum;
251   int Sequence_Framenum;
252   int Return_Value;
253
254   Bitstream_Framenum = *Bitstream_Framenumber;
255   Sequence_Framenum=0;
256
257   Initialize_Sequence();
258
259   /* decode picture whose header has already been parsed in 
260      Decode_Bitstream() */
261
262
263   Decode_Picture(Bitstream_Framenum, Sequence_Framenum);
264
265   /* update picture numbers */
266   if ( !Second_Field )
267   {
268     Bitstream_Framenum++;
269     Sequence_Framenum++;
270   }
271
272   /* loop through the rest of the pictures in the sequence */
273   while ((Return_Value=Headers()))
274   {
275     Decode_Picture(Bitstream_Framenum, Sequence_Framenum);
276
277     if ( !Second_Field )
278     {
279       Bitstream_Framenum++;
280       Sequence_Framenum++;
281     }
282   }
283
284   /* put last frame */
285   if (Sequence_Framenum!=0)
286   {
287     Output_Last_Frame_of_Sequence(Bitstream_Framenum);
288   }
289
290   Deinitialize_Sequence();
291
292 #ifdef VERIFY
293     Clear_Verify_Headers();
294 #endif /* VERIFY */
295
296   *Bitstream_Framenumber = Bitstream_Framenum;
297   return(Return_Value);
298 }
299 } // End "C" extern
300
301 namespace gdcm 
302 {
303 /**
304  * \brief   routine for MPEG decompression 
305  * @param fp pointer to an already open file descriptor 
306  *                      8 significant bits per pixel
307  * @param image_buffer to receive uncompressed pixels
308  * @param length length
309  * @return 1 on success, 0 on error
310  */
311
312 bool ReadMPEGFile (std::ifstream *fp, void *image_buffer, size_t length)
313 {
314   int ret, code;
315
316 #if 0
317   fp->read((char*)image_buffer, length);
318
319   ofstream out("/tmp/etiam.mpeg");
320   out.write((char*)image_buffer, length);
321   out.close();
322 #endif
323
324 //  Clear_Options();
325
326   /* decode command line arguments */
327 //  Process_Options(argc,argv);
328
329 #ifdef DEBUG
330   Print_Options();
331 #endif
332
333   ld = &base; /* select base layer context */
334
335   /* open MPEG base layer bitstream file(s) */
336   /* NOTE: this is either a base layer stream or a spatial enhancement stream */
337 #if 0
338   if ((base.Infile=open(Main_Bitstream_Filename,O_RDONLY|O_BINARY))<0)
339   {
340     fprintf(stderr,"Base layer input file %s not found\n", Main_Bitstream_Filename);
341     exit(1);
342   }
343 #else
344   base.Infile = -1; //DEBUG
345 #endif
346
347
348   if ( base.Infile != 0 )
349   {
350     Initialize_Buffer(); 
351   
352     if ( Show_Bits(8)==0x47 )
353     {
354       sprintf(Error_Text,"Decoder currently does not parse transport streams\n");
355       Error(Error_Text);
356     }
357
358     next_start_code();
359     code = Show_Bits(32);
360
361     switch(code)
362     {
363     case SEQUENCE_HEADER_CODE:
364       break;
365     case PACK_START_CODE:
366       System_Stream_Flag = 1;
367     case VIDEO_ELEMENTARY_STREAM:
368       System_Stream_Flag = 1;
369       break;
370     default:
371       sprintf(Error_Text,"Unable to recognize stream type\n");
372       Error(Error_Text);
373       break;
374     }
375
376     //lseek(base.Infile, 0l, SEEK_SET);
377     //fp->seekg(mpeg_start, ios_base::beg);
378     Initialize_Buffer(); 
379   }
380
381   if ( base.Infile!=0 )
382   {
383     //lseek(base.Infile, 0l, SEEK_SET);
384     //fp->seekg(mpeg_start, ios_base::beg);
385   }
386
387   Initialize_Buffer(); 
388
389   if ( Two_Streams )
390   {
391   abort();
392     ld = &enhan; /* select enhancement layer context */
393
394     if ( (enhan.Infile = open(Enhancement_Layer_Bitstream_Filename,O_RDONLY|O_BINARY))<0)
395     {
396       sprintf(Error_Text,"enhancment layer bitstream file %s not found\n",
397         Enhancement_Layer_Bitstream_Filename);
398
399       Error(Error_Text);
400     }
401
402     Initialize_Buffer();
403     ld = &base;
404   }
405
406   Initialize_Decoder();
407
408   ret = Decode_Bitstream();
409
410   //close(base.Infile);
411
412   if ( Two_Streams )
413     {
414     abort();
415     close(enhan.Infile);
416     }
417
418   return ret;
419 }
420
421 } // end namespace gdcm