fixed -d (--scale) parameter
[swftools.git] / avi2swf / videoreader_vfw.cc
1 /* videoreader_vfw.cc
2    Read avi files using Video For Windows (vfw).
3
4    Part of the swftools package.
5    
6    Copyright (c) 2004 Matthias Kramm <kramm@quiss.org>
7  
8    This program is free software; you can redistribute it and/or modify
9    it under the terms of the GNU General Public License as published by
10    the Free Software Foundation; either version 2 of the License, or
11    (at your option) any later version.
12
13    This program is distributed in the hope that it will be useful,
14    but WITHOUT ANY WARRANTY; without even the implied warranty of
15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16    GNU General Public License for more details.
17
18    You should have received a copy of the GNU General Public License
19    along with this program; if not, write to the Free Software
20    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
21
22 #include "videoreader.h"
23 #ifdef WIN32
24 #include <windows.h>
25 #include <vfw.h>
26 #include <stdlib.h>
27 #include <stdio.h>
28
29 typedef struct _videoreader_vfw_internal { 
30     //video:
31     PAVISTREAM vs;
32     //audio:
33     PAVISTREAM as;
34
35     PGETFRAME getframe;
36     IAVIFile* avifile;
37     BITMAPINFOHEADER bitmap;
38     WAVEFORMATEX waveformat;
39
40     int audio_eof;
41     int video_eof;
42
43     int video_pos;
44     int video_end;
45
46     int audio_pos;
47     int audio_end;
48
49     float fps;
50     int width,height;
51
52     int samplerate;
53     int channels;
54
55     int flip;
56 } videoreader_vfw_internal_t;
57
58 static int avifile_initialized = 0;
59 static int verbose;
60
61 #define _TRACE_ {printf("vfw: %s: %d (%s)\n",__FILE__,__LINE__,__func__);fflush(stdout);}
62
63 static int bitmap_to_rgba(BITMAPINFOHEADER*bi, void*buffer, const int dest_width, const int dest_height, int flip)
64 {
65     UCHAR*data = (UCHAR*)(bi+1); // actual bitmap data starts after the header
66
67     if(bi->biPlanes!=1 || bi->biCompression!=0 || bi->biBitCount%4!=0) {
68         /* unsupported format */
69         fprintf(stderr, "bitmap_to_rgba: unsupported format: biPlanes=%d, biCompression=%d biBitCount=%d\n",
70                 bi->biPlanes, bi->biCompression, bi->biBitCount);
71         return 0;
72     }
73     
74     ULONG*dest = (ULONG*)buffer;
75
76     int width = abs(bi->biWidth);
77     int height = abs(bi->biHeight);
78     if(dest_width != width || dest_height != height) {
79         /* TODO: size conversion */
80         fprintf(stderr, "size mismatch: %dx%d != %dx%d\n", width, height, dest_width, dest_height);
81         return 0;
82     }
83
84     /* convert the various image types to RGBA-
85        TODO: is there some way to let the Windows API do this? */
86     int bytesperpixel = ((bi->biWidth*bi->biBitCount)+7)&~7;
87     int linex = ((bytesperpixel/8)+3)&~3;
88     memset(dest, 255, dest_width*dest_height*4);//pre-fill alpha channel
89
90     const int starty = flip? 0 : dest_height-1;
91     const int endy   = flip? dest_height : -1;
92     const int yinc   = flip? 1 : -1;
93
94     if(verbose) {
95         printf("vfw: Convering scanlines %d to %d from bpp %d, %d stepping, flip=%d\n", starty, endy, bi->biBitCount, yinc, flip);
96     }
97
98     if(bi->biBitCount==1) {
99         UCHAR*img = data;
100         int y;
101         for(y=starty;y!=endy;y+=yinc) {
102             UCHAR*line = &img[linex*y];
103             int x;
104             for(x=0;x<dest_width;x++) {
105                 *dest++ = 255*((line[x/8]>>(x&7))&1);
106             }
107         }
108     } else if(bi->biBitCount==4) {
109         UCHAR*img = &data[bi->biClrUsed*4];
110         UCHAR*pal = data;
111         int y;
112         for(y=starty;y!=endy;y+=yinc) {
113             UCHAR*line = &img[linex*y];
114             int x;
115             for(x=0;x<dest_width/2;x++) {
116                 *dest++ = 255|pal[(line[0]>>4)<<2|0]<<8|pal[(line[0]>>4)<<2|1]<<16|pal[(line[0]>>4)<<2|2]<<24;
117                 *dest++ = 255|pal[(line[0]&0x0f)<<2|0]<<8|pal[(line[0]&0x0f)<<2|1]<<16|pal[(line[0]&0x0f)<<2|2]<<24;
118                 line++;
119             }
120         }
121     } else if(bi->biBitCount==8) {
122         UCHAR*img = &data[bi->biClrUsed*4];
123         UCHAR*pal = data;
124         int y;
125         for(y=starty;y!=endy;y+=yinc) {
126             UCHAR*line = &img[linex*y];
127             int x;
128             for(x=0;x<dest_width;x++) {
129                 *dest++ = 255|pal[line[0]*4+2]<<8|pal[line[0]*4+1]<<16|pal[line[0]*4+0]<<24;
130                 line++;
131             }
132         }
133     } else if(bi->biBitCount==16) {
134         UCHAR*img = data;
135         int y;
136         for(y=starty;y!=endy;y+=yinc) {
137             UCHAR*line = &img[linex*y];
138             int x;
139             for(x=0;x<dest_width;x++) {
140                 USHORT c = line[0]|line[1]<<8;
141                 *dest++ = 255|(c&0x1f)<<(24+3)|(c>>5&0x1f)<<(16+3)|(c>>10&0x1f)<<(8+3);
142                 line+=2;
143             }
144         }
145     } else if(bi->biBitCount==24) {
146         UCHAR*img = data;
147         int y;
148         for(y=starty;y!=endy;y+=yinc) {
149             UCHAR*line = &img[linex*y];
150             int x;
151             for(x=0;x<dest_width;x++) {
152                 *dest++ = 255|line[2]<<8|line[1]<<16|line[0]<<24;
153                 line+=3;
154             }
155         }
156     } else if(bi->biBitCount==32) {
157         UCHAR*img = data;
158         int y;
159         for(y=starty;y!=endy;y+=yinc) {
160             UCHAR*line = &img[linex*y];
161             int x;
162             for(x=0;x<dest_width;x++) {
163                 *dest++ = 255|line[0]<<8|line[1]<<16|line[2]<<24;
164                 line+=4;
165             }
166         }
167     } else {
168         fprintf(stderr, "Unsupported format: bitcount=%d\n", bi->biBitCount);
169         return 0;
170     }
171     return 1;
172 }
173
174 static int videoreader_vfw_getimage(videoreader_t* vr, void*buffer)
175 {
176     videoreader_vfw_internal_t* i = (videoreader_vfw_internal_t*)vr->internal;
177
178     if (i->video_pos >= i->video_end)
179         i->video_eof = 1;
180
181     if(i->video_eof)
182         return 0;
183
184     LPBITMAPINFOHEADER bi;
185     bi = (LPBITMAPINFOHEADER)AVIStreamGetFrame(i->getframe, i->video_pos);
186         
187     i->video_pos++;
188     vr->frame++;
189
190     if(!bi) {
191         fprintf(stderr, "AVIStreamGetFrame failed\n");
192         return 0;
193     }
194     
195     if(!bitmap_to_rgba(bi, buffer, i->width, i->height, i->flip)) {
196         fprintf(stderr, "couldn't convert bitmap to RGBA.\n");
197         return 0;
198     }
199     return i->width*i->height*4;
200 }
201
202 static int readAudioBlock(videoreader_vfw_internal_t* i, void*buf, int len)
203 {
204     LONG bytes;
205     LONG samples;
206     AVIStreamRead(i->as, i->audio_pos, len/(2*i->waveformat.nChannels), buf, len, &bytes, &samples);
207     i->audio_pos += samples;
208     return bytes;
209 }
210
211 static int videoreader_vfw_getsamples(videoreader_t* vr, void*buf, int num)
212 {
213     videoreader_vfw_internal_t* i = (videoreader_vfw_internal_t*)vr->internal;
214
215     if(i->audio_eof)
216         return 0;
217    
218     switch(i->waveformat.wBitsPerSample) {
219         case 1: {
220             int len = readAudioBlock(i, buf, num);
221             int t = len-1;
222             do {
223                 ((SHORT*)buf)[t] = ((((BYTE*)buf)[t>>3])>>(t&7))<<15;
224             } while(--t>=0);
225             if(!len) i->audio_eof = 1;
226             return len*8;
227         }
228         case 8: {
229             int len = readAudioBlock(i, buf, num);
230             int t = len-1;
231             do {
232                 ((SHORT*)buf)[t] = (((BYTE*)buf)[t]<<8)^0x8000;
233             } while(--t>=0);
234             if(!len) i->audio_eof = 1;
235             return len*2;
236         }
237         case 16: {
238             int len = readAudioBlock(i, buf, num);
239             if(!len) i->audio_eof = 1;
240             return len;
241         }
242         default: {
243             return 0;
244         }
245     }
246 }
247
248 static void videoreader_vfw_close(videoreader_t* vr)
249 {
250     videoreader_vfw_internal_t* i = (videoreader_vfw_internal_t*)vr->internal;
251
252     AVIStreamGetFrameClose(i->getframe);
253     if(i->vs) {
254         AVIStreamRelease(i->vs); i->vs = 0;
255     }
256     if(i->as) {
257         AVIStreamRelease(i->as); i->vs = 0;
258     }
259     AVIFileRelease(i->avifile); i->avifile = 0;
260     
261     AVIFileExit(); avifile_initialized=0;
262
263     free(vr->internal); vr->internal = 0;
264 }
265
266 static void videoreader_vfw_setparameter(videoreader_t*vr, char*name, char*value)
267 {
268     videoreader_vfw_internal_t* i = (videoreader_vfw_internal_t*)vr->internal;
269     if(!strcmp(name, "flip")) {
270         i->flip = atoi(value);
271     } else if(!strcmp(name, "verbose")) {
272         verbose = atoi(value);
273     }
274 }
275
276 int videoreader_vfw_open(videoreader_t* vr, char* filename)
277 {
278     memset(vr, 0, sizeof(videoreader_t));
279     if(!filename) {
280         /* codec query */
281         return 1;
282     }
283
284     videoreader_vfw_internal_t* i = (videoreader_vfw_internal_t*)malloc(sizeof(videoreader_vfw_internal_t));
285     memset(i, 0, sizeof(videoreader_vfw_internal_t));
286
287     vr->internal = i;
288     vr->getimage = videoreader_vfw_getimage;
289     vr->getsamples = videoreader_vfw_getsamples;
290     vr->close = videoreader_vfw_close;
291     vr->setparameter = videoreader_vfw_setparameter;
292
293     if(!avifile_initialized) {
294         AVIFileInit();
295     }
296     if(AVIFileOpen(&i->avifile, filename, OF_SHARE_DENY_WRITE, 0)) {
297         fprintf(stderr, "Couldn't open %s\n", filename);
298         return -1;
299     }
300     AVIFILEINFO info;
301     AVIFileInfo(i->avifile, &info, sizeof(info));
302    
303     /* calculate framerate */
304     i->fps = (double)info.dwRate/(double)info.dwScale;
305
306     if(verbose) {
307         printf("vfw: file %s has %f fps, and %d streams\n", i->fps, info.dwStreams);
308     }
309
310     unsigned int t=0;
311     while(t<info.dwStreams) {
312         PAVISTREAM stream;
313         if(AVIFileGetStream(i->avifile, &stream, streamtypeANY, t) != AVIERR_OK || !stream)
314             break; //video_end of (working) streams
315
316         AVISTREAMINFO streaminfo;
317         AVIStreamInfo(stream, &streaminfo, sizeof(streaminfo));
318
319         if (streaminfo.fccType == streamtypeVIDEO) {
320             /* video stream */
321
322             BITMAPINFOHEADER bitmap;
323             LONG size = sizeof(bitmap);
324             AVIStreamReadFormat(stream, 0, &bitmap, &size);
325
326             if(1) {
327                 i->bitmap = bitmap;
328                 i->vs = stream;
329                 i->width = abs(bitmap.biWidth);
330                 i->height = abs(bitmap.biHeight);
331             } else {
332                 fprintf(stderr, "Ignoring video stream: %dx%d compression=%d planes=%d\n", 
333                         abs(bitmap.biWidth), abs(bitmap.biHeight),
334                         bitmap.biCompression,bitmap.biPlanes);
335             }
336         }
337         else if (streaminfo.fccType == streamtypeAUDIO) {
338             /* audio stream */
339
340             WAVEFORMATEX waveformat;
341             LONG size = sizeof(waveformat);
342             AVIStreamReadFormat(stream, 0, &waveformat, &size);
343
344             if(waveformat.wBitsPerSample == 16 || 
345                waveformat.wBitsPerSample == 8 ||
346                waveformat.wBitsPerSample == 1
347                ) {
348                 i->waveformat = waveformat;
349                 i->as = stream;
350                 i->channels = waveformat.nChannels;
351                 i->samplerate = waveformat.nSamplesPerSec;
352             } else {
353                 fprintf(stderr, "Ignoring audio stream: bitspersample=%d\n", waveformat.wBitsPerSample);
354             }
355         }
356         t++;
357     }
358
359     if(i->vs) {
360         if(verbose) {
361             printf("vfw: video stream: %dx%d, %.2f\n", i->width, i->height, i->fps);
362         }
363         vr->width = i->width;
364         vr->height = i->height;
365         vr->fps = i->fps;
366     } else {
367         fprintf(stderr, "AVIReader: Warning: No video stream\n");
368     }
369     if(i->as) {
370         if(verbose) {
371             printf("vfw: audio stream: %d channels, %d samples/sec", i->channels, i->samplerate);
372         }
373         vr->channels = i->channels;
374         vr->samplerate = i->samplerate;
375     } else {
376         fprintf(stderr, "AVIReader: Warning: No audio stream\n");
377     }
378     
379     i->getframe = AVIStreamGetFrameOpen(i->vs, 0);
380     if(!i->getframe) {
381         fprintf(stderr, "Couldn't initialize AVIStream for %s- codec missing?\n", filename);
382         return -1;
383     }
384     
385     i->video_pos = AVIStreamStart(i->vs);
386     i->video_end = AVIStreamEnd(i->vs);
387     i->audio_pos = 0;
388     i->audio_end = 0x7fffffff;
389
390     return 0;
391 }
392
393 #else //WIN32
394
395 int videoreader_vfw_open(videoreader_t* vr, char* filename)
396 {
397     return -1;
398 }
399
400 #endif //WIN32
401