author | mickeyl <mickeyl> | 2003-04-18 00:37:32 (UTC) |
---|---|---|
committer | mickeyl <mickeyl> | 2003-04-18 00:37:32 (UTC) |
commit | 81776eb70dcad6748b8494ff13fbd048c60c1fae (patch) (unidiff) | |
tree | 9bb13dc582ccfd79e934ee30f6b647046b7a35c3 /noncore/multimedia/camera | |
parent | 39c72eb2d35aecb3a057b347df5231d1dbfdd37c (diff) | |
download | opie-81776eb70dcad6748b8494ff13fbd048c60c1fae.zip opie-81776eb70dcad6748b8494ff13fbd048c60c1fae.tar.gz opie-81776eb70dcad6748b8494ff13fbd048c60c1fae.tar.bz2 |
add jpeg2avi for postprocessing a series of jpeg frames into an avi
-rw-r--r-- | noncore/multimedia/camera/jpegtoavi/CHANGELOG | 7 | ||||
-rw-r--r-- | noncore/multimedia/camera/jpegtoavi/COPYING | 341 | ||||
-rw-r--r-- | noncore/multimedia/camera/jpegtoavi/README | 49 | ||||
-rw-r--r-- | noncore/multimedia/camera/jpegtoavi/avifmt.h | 116 | ||||
-rw-r--r-- | noncore/multimedia/camera/jpegtoavi/byteswap.h | 31 | ||||
-rw-r--r-- | noncore/multimedia/camera/jpegtoavi/jpegtoavi.c | 349 |
6 files changed, 893 insertions, 0 deletions
diff --git a/noncore/multimedia/camera/jpegtoavi/CHANGELOG b/noncore/multimedia/camera/jpegtoavi/CHANGELOG new file mode 100644 index 0000000..a54b960 --- a/dev/null +++ b/noncore/multimedia/camera/jpegtoavi/CHANGELOG | |||
@@ -0,0 +1,7 @@ | |||
1 | 18/03/03 | ||
2 | |||
3 | 1. (BUG*) reported size in -fsz mode was 8 bytes too small | ||
4 | 2. (NEW) added -f switch for specifying the frame rate in fps | ||
5 | 3. (BUG*) some DWORDs weren't being converted to little-endian | ||
6 | 4. (NEW) added --version switch | ||
7 | 5. *** VERSION 1.2 frozen *** \ No newline at end of file | ||
diff --git a/noncore/multimedia/camera/jpegtoavi/COPYING b/noncore/multimedia/camera/jpegtoavi/COPYING new file mode 100644 index 0000000..afd5a94 --- a/dev/null +++ b/noncore/multimedia/camera/jpegtoavi/COPYING | |||
@@ -0,0 +1,341 @@ | |||
1 | |||
2 | GNU GENERAL PUBLIC LICENSE | ||
3 | Version 2, June 1991 | ||
4 | |||
5 | Copyright (C) 1989, 1991 Free Software Foundation, Inc. | ||
6 | 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | ||
7 | Everyone is permitted to copy and distribute verbatim copies | ||
8 | of this license document, but changing it is not allowed. | ||
9 | |||
10 | Preamble | ||
11 | |||
12 | The licenses for most software are designed to take away your | ||
13 | freedom to share and change it. By contrast, the GNU General Public | ||
14 | License is intended to guarantee your freedom to share and change free | ||
15 | software--to make sure the software is free for all its users. This | ||
16 | General Public License applies to most of the Free Software | ||
17 | Foundation's software and to any other program whose authors commit to | ||
18 | using it. (Some other Free Software Foundation software is covered by | ||
19 | the GNU Library General Public License instead.) You can apply it to | ||
20 | your programs, too. | ||
21 | |||
22 | When we speak of free software, we are referring to freedom, not | ||
23 | price. Our General Public Licenses are designed to make sure that you | ||
24 | have the freedom to distribute copies of free software (and charge for | ||
25 | this service if you wish), that you receive source code or can get it | ||
26 | if you want it, that you can change the software or use pieces of it | ||
27 | in new free programs; and that you know you can do these things. | ||
28 | |||
29 | To protect your rights, we need to make restrictions that forbid | ||
30 | anyone to deny you these rights or to ask you to surrender the rights. | ||
31 | These restrictions translate to certain responsibilities for you if you | ||
32 | distribute copies of the software, or if you modify it. | ||
33 | |||
34 | For example, if you distribute copies of such a program, whether | ||
35 | gratis or for a fee, you must give the recipients all the rights that | ||
36 | you have. You must make sure that they, too, receive or can get the | ||
37 | source code. And you must show them these terms so they know their | ||
38 | rights. | ||
39 | |||
40 | We protect your rights with two steps: (1) copyright the software, and | ||
41 | (2) offer you this license which gives you legal permission to copy, | ||
42 | distribute and/or modify the software. | ||
43 | |||
44 | Also, for each author's protection and ours, we want to make certain | ||
45 | that everyone understands that there is no warranty for this free | ||
46 | software. If the software is modified by someone else and passed on, we | ||
47 | want its recipients to know that what they have is not the original, so | ||
48 | that any problems introduced by others will not reflect on the original | ||
49 | authors' reputations. | ||
50 | |||
51 | Finally, any free program is threatened constantly by software | ||
52 | patents. We wish to avoid the danger that redistributors of a free | ||
53 | program will individually obtain patent licenses, in effect making the | ||
54 | program proprietary. To prevent this, we have made it clear that any | ||
55 | patent must be licensed for everyone's free use or not licensed at all. | ||
56 | |||
57 | The precise terms and conditions for copying, distribution and | ||
58 | modification follow. | ||
59 | |||
60 | GNU GENERAL PUBLIC LICENSE | ||
61 | TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION | ||
62 | |||
63 | 0. This License applies to any program or other work which contains | ||
64 | a notice placed by the copyright holder saying it may be distributed | ||
65 | under the terms of this General Public License. The "Program", below, | ||
66 | refers to any such program or work, and a "work based on the Program" | ||
67 | means either the Program or any derivative work under copyright law: | ||
68 | that is to say, a work containing the Program or a portion of it, | ||
69 | either verbatim or with modifications and/or translated into another | ||
70 | language. (Hereinafter, translation is included without limitation in | ||
71 | the term "modification".) Each licensee is addressed as "you". | ||
72 | |||
73 | Activities other than copying, distribution and modification are not | ||
74 | covered by this License; they are outside its scope. The act of | ||
75 | running the Program is not restricted, and the output from the Program | ||
76 | is covered only if its contents constitute a work based on the | ||
77 | Program (independent of having been made by running the Program). | ||
78 | Whether that is true depends on what the Program does. | ||
79 | |||
80 | 1. You may copy and distribute verbatim copies of the Program's | ||
81 | source code as you receive it, in any medium, provided that you | ||
82 | conspicuously and appropriately publish on each copy an appropriate | ||
83 | copyright notice and disclaimer of warranty; keep intact all the | ||
84 | notices that refer to this License and to the absence of any warranty; | ||
85 | and give any other recipients of the Program a copy of this License | ||
86 | along with the Program. | ||
87 | |||
88 | You may charge a fee for the physical act of transferring a copy, and | ||
89 | you may at your option offer warranty protection in exchange for a fee. | ||
90 | |||
91 | 2. You may modify your copy or copies of the Program or any portion | ||
92 | of it, thus forming a work based on the Program, and copy and | ||
93 | distribute such modifications or work under the terms of Section 1 | ||
94 | above, provided that you also meet all of these conditions: | ||
95 | |||
96 | a) You must cause the modified files to carry prominent notices | ||
97 | stating that you changed the files and the date of any change. | ||
98 | |||
99 | b) You must cause any work that you distribute or publish, that in | ||
100 | whole or in part contains or is derived from the Program or any | ||
101 | part thereof, to be licensed as a whole at no charge to all third | ||
102 | parties under the terms of this License. | ||
103 | |||
104 | c) If the modified program normally reads commands interactively | ||
105 | when run, you must cause it, when started running for such | ||
106 | interactive use in the most ordinary way, to print or display an | ||
107 | announcement including an appropriate copyright notice and a | ||
108 | notice that there is no warranty (or else, saying that you provide | ||
109 | a warranty) and that users may redistribute the program under | ||
110 | these conditions, and telling the user how to view a copy of this | ||
111 | License. (Exception: if the Program itself is interactive but | ||
112 | does not normally print such an announcement, your work based on | ||
113 | the Program is not required to print an announcement.) | ||
114 | |||
115 | These requirements apply to the modified work as a whole. If | ||
116 | identifiable sections of that work are not derived from the Program, | ||
117 | and can be reasonably considered independent and separate works in | ||
118 | themselves, then this License, and its terms, do not apply to those | ||
119 | sections when you distribute them as separate works. But when you | ||
120 | distribute the same sections as part of a whole which is a work based | ||
121 | on the Program, the distribution of the whole must be on the terms of | ||
122 | this License, whose permissions for other licensees extend to the | ||
123 | entire whole, and thus to each and every part regardless of who wrote it. | ||
124 | |||
125 | Thus, it is not the intent of this section to claim rights or contest | ||
126 | your rights to work written entirely by you; rather, the intent is to | ||
127 | exercise the right to control the distribution of derivative or | ||
128 | collective works based on the Program. | ||
129 | |||
130 | In addition, mere aggregation of another work not based on the Program | ||
131 | with the Program (or with a work based on the Program) on a volume of | ||
132 | a storage or distribution medium does not bring the other work under | ||
133 | the scope of this License. | ||
134 | |||
135 | 3. You may copy and distribute the Program (or a work based on it, | ||
136 | under Section 2) in object code or executable form under the terms of | ||
137 | Sections 1 and 2 above provided that you also do one of the following: | ||
138 | |||
139 | a) Accompany it with the complete corresponding machine-readable | ||
140 | source code, which must be distributed under the terms of Sections | ||
141 | 1 and 2 above on a medium customarily used for software interchange; or, | ||
142 | |||
143 | b) Accompany it with a written offer, valid for at least three | ||
144 | years, to give any third party, for a charge no more than your | ||
145 | cost of physically performing source distribution, a complete | ||
146 | machine-readable copy of the corresponding source code, to be | ||
147 | distributed under the terms of Sections 1 and 2 above on a medium | ||
148 | customarily used for software interchange; or, | ||
149 | |||
150 | c) Accompany it with the information you received as to the offer | ||
151 | to distribute corresponding source code. (This alternative is | ||
152 | allowed only for noncommercial distribution and only if you | ||
153 | received the program in object code or executable form with such | ||
154 | an offer, in accord with Subsection b above.) | ||
155 | |||
156 | The source code for a work means the preferred form of the work for | ||
157 | making modifications to it. For an executable work, complete source | ||
158 | code means all the source code for all modules it contains, plus any | ||
159 | associated interface definition files, plus the scripts used to | ||
160 | control compilation and installation of the executable. However, as a | ||
161 | special exception, the source code distributed need not include | ||
162 | anything that is normally distributed (in either source or binary | ||
163 | form) with the major components (compiler, kernel, and so on) of the | ||
164 | operating system on which the executable runs, unless that component | ||
165 | itself accompanies the executable. | ||
166 | |||
167 | If distribution of executable or object code is made by offering | ||
168 | access to copy from a designated place, then offering equivalent | ||
169 | access to copy the source code from the same place counts as | ||
170 | distribution of the source code, even though third parties are not | ||
171 | compelled to copy the source along with the object code. | ||
172 | |||
173 | 4. You may not copy, modify, sublicense, or distribute the Program | ||
174 | except as expressly provided under this License. Any attempt | ||
175 | otherwise to copy, modify, sublicense or distribute the Program is | ||
176 | void, and will automatically terminate your rights under this License. | ||
177 | However, parties who have received copies, or rights, from you under | ||
178 | this License will not have their licenses terminated so long as such | ||
179 | parties remain in full compliance. | ||
180 | |||
181 | 5. You are not required to accept this License, since you have not | ||
182 | signed it. However, nothing else grants you permission to modify or | ||
183 | distribute the Program or its derivative works. These actions are | ||
184 | prohibited by law if you do not accept this License. Therefore, by | ||
185 | modifying or distributing the Program (or any work based on the | ||
186 | Program), you indicate your acceptance of this License to do so, and | ||
187 | all its terms and conditions for copying, distributing or modifying | ||
188 | the Program or works based on it. | ||
189 | |||
190 | 6. Each time you redistribute the Program (or any work based on the | ||
191 | Program), the recipient automatically receives a license from the | ||
192 | original licensor to copy, distribute or modify the Program subject to | ||
193 | these terms and conditions. You may not impose any further | ||
194 | restrictions on the recipients' exercise of the rights granted herein. | ||
195 | You are not responsible for enforcing compliance by third parties to | ||
196 | this License. | ||
197 | |||
198 | 7. If, as a consequence of a court judgment or allegation of patent | ||
199 | infringement or for any other reason (not limited to patent issues), | ||
200 | conditions are imposed on you (whether by court order, agreement or | ||
201 | otherwise) that contradict the conditions of this License, they do not | ||
202 | excuse you from the conditions of this License. If you cannot | ||
203 | distribute so as to satisfy simultaneously your obligations under this | ||
204 | License and any other pertinent obligations, then as a consequence you | ||
205 | may not distribute the Program at all. For example, if a patent | ||
206 | license would not permit royalty-free redistribution of the Program by | ||
207 | all those who receive copies directly or indirectly through you, then | ||
208 | the only way you could satisfy both it and this License would be to | ||
209 | refrain entirely from distribution of the Program. | ||
210 | |||
211 | If any portion of this section is held invalid or unenforceable under | ||
212 | any particular circumstance, the balance of the section is intended to | ||
213 | apply and the section as a whole is intended to apply in other | ||
214 | circumstances. | ||
215 | |||
216 | It is not the purpose of this section to induce you to infringe any | ||
217 | patents or other property right claims or to contest validity of any | ||
218 | such claims; this section has the sole purpose of protecting the | ||
219 | integrity of the free software distribution system, which is | ||
220 | implemented by public license practices. Many people have made | ||
221 | generous contributions to the wide range of software distributed | ||
222 | through that system in reliance on consistent application of that | ||
223 | system; it is up to the author/donor to decide if he or she is willing | ||
224 | to distribute software through any other system and a licensee cannot | ||
225 | impose that choice. | ||
226 | |||
227 | This section is intended to make thoroughly clear what is believed to | ||
228 | be a consequence of the rest of this License. | ||
229 | |||
230 | 8. If the distribution and/or use of the Program is restricted in | ||
231 | certain countries either by patents or by copyrighted interfaces, the | ||
232 | original copyright holder who places the Program under this License | ||
233 | may add an explicit geographical distribution limitation excluding | ||
234 | those countries, so that distribution is permitted only in or among | ||
235 | countries not thus excluded. In such case, this License incorporates | ||
236 | the limitation as if written in the body of this License. | ||
237 | |||
238 | 9. The Free Software Foundation may publish revised and/or new versions | ||
239 | of the General Public License from time to time. Such new versions will | ||
240 | be similar in spirit to the present version, but may differ in detail to | ||
241 | address new problems or concerns. | ||
242 | |||
243 | Each version is given a distinguishing version number. If the Program | ||
244 | specifies a version number of this License which applies to it and "any | ||
245 | later version", you have the option of following the terms and conditions | ||
246 | either of that version or of any later version published by the Free | ||
247 | Software Foundation. If the Program does not specify a version number of | ||
248 | this License, you may choose any version ever published by the Free Software | ||
249 | Foundation. | ||
250 | |||
251 | 10. If you wish to incorporate parts of the Program into other free | ||
252 | programs whose distribution conditions are different, write to the author | ||
253 | to ask for permission. For software which is copyrighted by the Free | ||
254 | Software Foundation, write to the Free Software Foundation; we sometimes | ||
255 | make exceptions for this. Our decision will be guided by the two goals | ||
256 | of preserving the free status of all derivatives of our free software and | ||
257 | of promoting the sharing and reuse of software generally. | ||
258 | |||
259 | NO WARRANTY | ||
260 | |||
261 | 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY | ||
262 | FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN | ||
263 | OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES | ||
264 | PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED | ||
265 | OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF | ||
266 | MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS | ||
267 | TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE | ||
268 | PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, | ||
269 | REPAIR OR CORRECTION. | ||
270 | |||
271 | 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING | ||
272 | WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR | ||
273 | REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, | ||
274 | INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING | ||
275 | OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED | ||
276 | TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY | ||
277 | YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER | ||
278 | PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE | ||
279 | POSSIBILITY OF SUCH DAMAGES. | ||
280 | |||
281 | END OF TERMS AND CONDITIONS | ||
282 | |||
283 | How to Apply These Terms to Your New Programs | ||
284 | |||
285 | If you develop a new program, and you want it to be of the greatest | ||
286 | possible use to the public, the best way to achieve this is to make it | ||
287 | free software which everyone can redistribute and change under these terms. | ||
288 | |||
289 | To do so, attach the following notices to the program. It is safest | ||
290 | to attach them to the start of each source file to most effectively | ||
291 | convey the exclusion of warranty; and each file should have at least | ||
292 | the "copyright" line and a pointer to where the full notice is found. | ||
293 | |||
294 | <one line to give the program's name and a brief idea of what it does.> | ||
295 | Copyright (C) <year> <name of author> | ||
296 | |||
297 | This program is free software; you can redistribute it and/or modify | ||
298 | it under the terms of the GNU General Public License as published by | ||
299 | the Free Software Foundation; either version 2 of the License, or | ||
300 | (at your option) any later version. | ||
301 | |||
302 | This program is distributed in the hope that it will be useful, | ||
303 | but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
304 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
305 | GNU General Public License for more details. | ||
306 | |||
307 | You should have received a copy of the GNU General Public License | ||
308 | along with this program; if not, write to the Free Software | ||
309 | Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | ||
310 | |||
311 | |||
312 | Also add information on how to contact you by electronic and paper mail. | ||
313 | |||
314 | If the program is interactive, make it output a short notice like this | ||
315 | when it starts in an interactive mode: | ||
316 | |||
317 | Gnomovision version 69, Copyright (C) year name of author | ||
318 | Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. | ||
319 | This is free software, and you are welcome to redistribute it | ||
320 | under certain conditions; type `show c' for details. | ||
321 | |||
322 | The hypothetical commands `show w' and `show c' should show the appropriate | ||
323 | parts of the General Public License. Of course, the commands you use may | ||
324 | be called something other than `show w' and `show c'; they could even be | ||
325 | mouse-clicks or menu items--whatever suits your program. | ||
326 | |||
327 | You should also get your employer (if you work as a programmer) or your | ||
328 | school, if any, to sign a "copyright disclaimer" for the program, if | ||
329 | necessary. Here is a sample; alter the names: | ||
330 | |||
331 | Yoyodyne, Inc., hereby disclaims all copyright interest in the program | ||
332 | `Gnomovision' (which makes passes at compilers) written by James Hacker. | ||
333 | |||
334 | <signature of Ty Coon>, 1 April 1989 | ||
335 | Ty Coon, President of Vice | ||
336 | |||
337 | This General Public License does not permit incorporating your program into | ||
338 | proprietary programs. If your program is a subroutine library, you may | ||
339 | consider it more useful to permit linking proprietary applications with the | ||
340 | library. If this is what you want to do, use the GNU Library General | ||
341 | Public License instead of this License. | ||
diff --git a/noncore/multimedia/camera/jpegtoavi/README b/noncore/multimedia/camera/jpegtoavi/README new file mode 100644 index 0000000..6a0057f --- a/dev/null +++ b/noncore/multimedia/camera/jpegtoavi/README | |||
@@ -0,0 +1,49 @@ | |||
1 | JPEGTOAVI | ||
2 | by Phillip Bruce | ||
3 | |||
4 | |||
5 | I. Introduction | ||
6 | |||
7 | In the tradition of the Unix computing philosophy, here is | ||
8 | yet another operator that does one simple task, namely the | ||
9 | creation of an AVI MJPEG file given a list of JPEG/JFIF files. | ||
10 | |||
11 | I had some difficulty in performing this extremely simple task | ||
12 | in Linux, mostly because it is so simple and all of the existing | ||
13 | code to do it lie at the bottom of complicated and more ambitious | ||
14 | projects--e.g. xawtv, avifile, etc. I then had to waste | ||
15 | time reading M$ docs and xawtv source to find out how to do it. | ||
16 | |||
17 | |||
18 | II. Installation | ||
19 | |||
20 | The code is pretty basic, and so it should be pretty easy to | ||
21 | install: "make all" compiles the program, "make install" | ||
22 | installs it. If you want the files to reside in some directory | ||
23 | besides /usr/local/bin and /usr/local/man, edit "Makefile". | ||
24 | |||
25 | |||
26 | II. Usage | ||
27 | |||
28 | There are three basic modes of operation: | ||
29 | |||
30 | 1. jpegtoavi per_usec width height img1 [img2 ... imgN] | ||
31 | 2. jpegtoavi -f fps width height img1 [img2 ... imgN] | ||
32 | 3. jpegtoavi -fsz img1 [img2 .. imgN] | ||
33 | |||
34 | The first two print an AVI to STDOUT using the width and height | ||
35 | parameters and the images named in chronological order. (No | ||
36 | checks are made on the validity of the JPEG/JFIFs or their | ||
37 | dimensions.) The first mode specifies the frame rate in | ||
38 | terms of the period in microseconds for each frame, whereas | ||
39 | the second specifies frames per second. | ||
40 | |||
41 | The third mode was added to give size hints during the transfer | ||
42 | of AVIs without the use of a temporary file. Instead of | ||
43 | generating the AVI it outputs the size in bytes that of the AVI | ||
44 | that could have been generated. | ||
45 | |||
46 | |||
47 | III. Contact, Bug Reports, and Suggestions | ||
48 | |||
49 | Send them to me at dI77IHd@yahoo.com \ No newline at end of file | ||
diff --git a/noncore/multimedia/camera/jpegtoavi/avifmt.h b/noncore/multimedia/camera/jpegtoavi/avifmt.h new file mode 100644 index 0000000..53ce60d --- a/dev/null +++ b/noncore/multimedia/camera/jpegtoavi/avifmt.h | |||
@@ -0,0 +1,116 @@ | |||
1 | #ifndef _AVIFMT_HH_ | ||
2 | #define _AVIFMT_HH_ | ||
3 | |||
4 | /* 4 bytes */ | ||
5 | typedef int WORD; | ||
6 | typedef unsigned int DWORD; | ||
7 | /* 1 byte */ | ||
8 | typedef char BYTE; | ||
9 | |||
10 | |||
11 | /* flags for use in flags in AVI_avih */ | ||
12 | const DWORD AVIF_HASINDEX=0x00000010;/* index at end of file */ | ||
13 | const DWORD AVIF_MUSTUSEINDEX=0x00000020; | ||
14 | const DWORD AVIF_ISINTERLEAVED=0x00000100; | ||
15 | const DWORD AVIF_TRUSTCKTYPE=0x00000800; | ||
16 | const DWORD AVIF_WASCAPTUREFILE=0x00010000; | ||
17 | const DWORD AVIF_COPYRIGHTED=0x00020000; | ||
18 | |||
19 | |||
20 | struct AVI_avih { | ||
21 | DWORD us_per_frame;// frame display rate (or 0L) | ||
22 | DWORD max_bytes_per_sec;// max. transfer rate | ||
23 | DWORD padding;// pad to multiples of this size; | ||
24 | // normally 2K. | ||
25 | DWORD flags; | ||
26 | DWORD tot_frames; // # frames in file | ||
27 | DWORD init_frames; | ||
28 | DWORD streams; | ||
29 | DWORD buff_sz; | ||
30 | DWORD width; | ||
31 | DWORD height; | ||
32 | DWORD reserved[4]; | ||
33 | }; | ||
34 | |||
35 | |||
36 | struct AVI_strh { | ||
37 | unsigned char type[4]; /* stream type */ | ||
38 | unsigned char handler[4]; | ||
39 | DWORD flags; | ||
40 | DWORD priority; | ||
41 | DWORD init_frames; /* initial frames (???) */ | ||
42 | DWORD scale; | ||
43 | DWORD rate; | ||
44 | DWORD start; | ||
45 | DWORD length; | ||
46 | DWORD buff_sz; /* suggested buffer size */ | ||
47 | DWORD quality; | ||
48 | DWORD sample_sz; | ||
49 | /* | ||
50 | DWORD frame[4]; | ||
51 | XXX 16 bytes ? */ | ||
52 | }; | ||
53 | |||
54 | |||
55 | struct AVI_strf { /* == BitMapInfoHeader */ | ||
56 | DWORD sz; | ||
57 | DWORD width; | ||
58 | DWORD height; | ||
59 | DWORD planes_bit_cnt; | ||
60 | unsigned char compression[4]; | ||
61 | DWORD image_sz; | ||
62 | DWORD xpels_meter; | ||
63 | DWORD ypels_meter; | ||
64 | DWORD num_colors; /* used colors */ | ||
65 | DWORD imp_colors; /* important colors */ | ||
66 | /* may be more for some codecs */ | ||
67 | }; | ||
68 | |||
69 | |||
70 | struct AVI_list_hdr { | ||
71 | unsigned char id[4]; | ||
72 | DWORD sz; | ||
73 | unsigned char type[4]; | ||
74 | }; | ||
75 | |||
76 | |||
77 | struct AVI_list_odml { | ||
78 | struct AVI_list_hdr list_hdr; | ||
79 | |||
80 | unsigned char id[4]; | ||
81 | DWORD sz; | ||
82 | DWORD frames; | ||
83 | }; | ||
84 | |||
85 | |||
86 | struct AVI_list_strl { | ||
87 | struct AVI_list_hdr list_hdr; | ||
88 | |||
89 | /* chunk strh */ | ||
90 | unsigned char strh_id[4]; | ||
91 | DWORD strh_sz; | ||
92 | struct AVI_strh strh; | ||
93 | |||
94 | /* chunk strf */ | ||
95 | unsigned char strf_id[4]; | ||
96 | DWORD strf_sz; | ||
97 | struct AVI_strf strf; | ||
98 | |||
99 | /* list odml */ | ||
100 | struct AVI_list_odml list_odml; | ||
101 | }; | ||
102 | |||
103 | |||
104 | struct AVI_list_hdrl { | ||
105 | struct AVI_list_hdr list_hdr; | ||
106 | |||
107 | /* chunk avih */ | ||
108 | unsigned char avih_id[4]; | ||
109 | DWORD avih_sz; | ||
110 | struct AVI_avih avih; | ||
111 | |||
112 | /* list strl */ | ||
113 | struct AVI_list_strl strl; | ||
114 | }; | ||
115 | |||
116 | #endif | ||
diff --git a/noncore/multimedia/camera/jpegtoavi/byteswap.h b/noncore/multimedia/camera/jpegtoavi/byteswap.h new file mode 100644 index 0000000..17ab6cc --- a/dev/null +++ b/noncore/multimedia/camera/jpegtoavi/byteswap.h | |||
@@ -0,0 +1,31 @@ | |||
1 | #ifndef _BYTESWAP_H_ | ||
2 | #define _BYTESWAP_H_ | ||
3 | |||
4 | #include <endian.h> | ||
5 | #include <sys/types.h> | ||
6 | |||
7 | #ifndef BYTE_ORDER | ||
8 | # error "Aiee: BYTE_ORDER not defined\n"; | ||
9 | #endif | ||
10 | |||
11 | #define SWAP2(x) (((x>>8) & 0x00ff) |\ | ||
12 | ((x<<8) & 0xff00)) | ||
13 | |||
14 | #define SWAP4(x) (((x>>24) & 0x000000ff) |\ | ||
15 | ((x>>8) & 0x0000ff00) |\ | ||
16 | ((x<<8) & 0x00ff0000) |\ | ||
17 | ((x<<24) & 0xff000000)) | ||
18 | |||
19 | #if BYTE_ORDER==BIG_ENDIAN | ||
20 | # define LILEND2(a) SWAP2((a)) | ||
21 | # define LILEND4(a) SWAP4((a)) | ||
22 | # define BIGEND2(a) (a) | ||
23 | # define BIGEND4(a) (a) | ||
24 | #else | ||
25 | # define LILEND2(a) (a) | ||
26 | # define LILEND4(a) (a) | ||
27 | # define BIGEND2(a) SWAP2((a)) | ||
28 | # define BIGEND4(a) SWAP4((a)) | ||
29 | #endif | ||
30 | |||
31 | #endif | ||
diff --git a/noncore/multimedia/camera/jpegtoavi/jpegtoavi.c b/noncore/multimedia/camera/jpegtoavi/jpegtoavi.c new file mode 100644 index 0000000..10a2f81 --- a/dev/null +++ b/noncore/multimedia/camera/jpegtoavi/jpegtoavi.c | |||
@@ -0,0 +1,349 @@ | |||
1 | /* | ||
2 | |||
3 | A simple converter of JPEGs to an AVI-MJPEG animation. | ||
4 | |||
5 | USAGE: | ||
6 | 1. jpegtoavi {usec per img} {img width} {img height} | ||
7 | {img1 .. imgN} | ||
8 | (writes AVI file to stdout) | ||
9 | |||
10 | 2. jpegtoavi -f {fps} {img width} {img height} | ||
11 | {img1 .. imgN} | ||
12 | (same as #1 but with period specified in terms of fps) | ||
13 | |||
14 | 3. jpegtoavi -fsz {img1 .. imgN} | ||
15 | (writes sz in bytes of such an AVI file to stdout) | ||
16 | */ | ||
17 | |||
18 | #define _LARGEFILE_SOURCE | ||
19 | #define _LARGEFILE64_SOURCE | ||
20 | |||
21 | #include <stdio.h> | ||
22 | #include "avifmt.h" | ||
23 | #include <string.h> | ||
24 | #include <sys/types.h> | ||
25 | #include <sys/stat.h> | ||
26 | #include <unistd.h> | ||
27 | #include <fcntl.h> | ||
28 | #include "byteswap.h" | ||
29 | #include <stdlib.h> | ||
30 | |||
31 | |||
32 | /* | ||
33 | spc: indicating file sz in bytes, -1 on error | ||
34 | */ | ||
35 | off_t file_sz(char *fn) | ||
36 | { | ||
37 | struct stat s; | ||
38 | if(stat(fn,&s)==-1) | ||
39 | return -1; | ||
40 | return s.st_size; | ||
41 | } | ||
42 | |||
43 | |||
44 | /* | ||
45 | spc: returning sum of sizes of named JPEGs, -1 on error; | ||
46 | file sizes adjusted to multiple of 4-bytes | ||
47 | pos: szarray, if non-0, contains true sizes of files | ||
48 | */ | ||
49 | off_t img_array_sz(char **img,int imgsz,DWORD *szarray) | ||
50 | { | ||
51 | off_t tmp,ret=0; | ||
52 | int i=0; | ||
53 | for(;i<imgsz;++i) { | ||
54 | if((tmp=file_sz(img[i]))==-1) | ||
55 | return -1; | ||
56 | if(szarray) | ||
57 | szarray[i]=(DWORD)tmp; | ||
58 | tmp+=((4-(tmp%4))%4); | ||
59 | ret+=tmp; | ||
60 | } | ||
61 | return ret; | ||
62 | } | ||
63 | |||
64 | |||
65 | /* | ||
66 | spc: printing 4 byte word in little-endian fmt | ||
67 | */ | ||
68 | void print_quartet(unsigned int i) | ||
69 | { | ||
70 | putchar(i%0x100); i/=0x100; | ||
71 | putchar(i%0x100); i/=0x100; | ||
72 | putchar(i%0x100); i/=0x100; | ||
73 | putchar(i%0x100); | ||
74 | } | ||
75 | |||
76 | |||
77 | inline void show_help(int argc,char **argv) | ||
78 | { | ||
79 | fprintf(stderr,"USAGE: jpegtoavi {usec per img} {img width} {img height} {img1 .. imgN}\n"); | ||
80 | fprintf(stderr," jpegtoavi -f {fps} {img width} {img height} {img1 .. imgN}\n"); | ||
81 | fprintf(stderr," jpegtoavi --fsz {img1 .. imgN}\n"); | ||
82 | } | ||
83 | |||
84 | |||
85 | int main(int argc,char **argv) | ||
86 | { | ||
87 | DWORD per_usec=1; | ||
88 | DWORD width; | ||
89 | DWORD height; | ||
90 | DWORD frames=1; | ||
91 | unsigned int fps; | ||
92 | unsigned short img0; | ||
93 | off64_t jpg_sz_64,riff_sz_64; | ||
94 | long jpg_sz=1; | ||
95 | const off64_t MAX_RIFF_SZ=2147483648LL; /* 2 Gb limit */ | ||
96 | DWORD riff_sz; | ||
97 | |||
98 | int fd,f; | ||
99 | long nbr,nbw,tnbw=0; | ||
100 | char buff[512]; | ||
101 | DWORD *szarray=0; | ||
102 | DWORD *offsets=0; | ||
103 | off_t mfsz,remnant; | ||
104 | |||
105 | struct AVI_list_hdrl hdrl={ | ||
106 | /* header */ | ||
107 | { | ||
108 | {'L','I','S','T'}, | ||
109 | LILEND4(sizeof(struct AVI_list_hdrl)-8), | ||
110 | {'h','d','r','l'} | ||
111 | }, | ||
112 | |||
113 | /* chunk avih */ | ||
114 | {'a','v','i','h'}, | ||
115 | LILEND4(sizeof(struct AVI_avih)), | ||
116 | { | ||
117 | LILEND4(per_usec), | ||
118 | LILEND4(1000000*(jpg_sz/frames)/per_usec), | ||
119 | LILEND4(0), | ||
120 | LILEND4(AVIF_HASINDEX), | ||
121 | LILEND4(frames), | ||
122 | LILEND4(0), | ||
123 | LILEND4(1), | ||
124 | LILEND4(0), | ||
125 | LILEND4(width), | ||
126 | LILEND4(height), | ||
127 | {LILEND4(0),LILEND4(0),LILEND4(0),LILEND4(0)} | ||
128 | }, | ||
129 | |||
130 | /* list strl */ | ||
131 | { | ||
132 | { | ||
133 | {'L','I','S','T'}, | ||
134 | LILEND4(sizeof(struct AVI_list_strl)-8), | ||
135 | {'s','t','r','l'} | ||
136 | }, | ||
137 | |||
138 | /* chunk strh */ | ||
139 | {'s','t','r','h'}, | ||
140 | LILEND4(sizeof(struct AVI_strh)), | ||
141 | { | ||
142 | {'v','i','d','s'}, | ||
143 | {'M','J','P','G'}, | ||
144 | LILEND4(0), | ||
145 | LILEND4(0), | ||
146 | LILEND4(0), | ||
147 | LILEND4(per_usec), | ||
148 | LILEND4(1000000), | ||
149 | LILEND4(0), | ||
150 | LILEND4(frames), | ||
151 | LILEND4(0), | ||
152 | LILEND4(0), | ||
153 | LILEND4(0) | ||
154 | }, | ||
155 | |||
156 | /* chunk strf */ | ||
157 | {'s','t','r','f'}, | ||
158 | sizeof(struct AVI_strf), | ||
159 | { | ||
160 | LILEND4(sizeof(struct AVI_strf)), | ||
161 | LILEND4(width), | ||
162 | LILEND4(height), | ||
163 | LILEND4(1+24*256*256), | ||
164 | {'M','J','P','G'}, | ||
165 | LILEND4(width*height*3), | ||
166 | LILEND4(0), | ||
167 | LILEND4(0), | ||
168 | LILEND4(0), | ||
169 | LILEND4(0) | ||
170 | }, | ||
171 | |||
172 | /* list odml */ | ||
173 | { | ||
174 | { | ||
175 | {'L','I','S','T'}, | ||
176 | LILEND4(16), | ||
177 | {'o','d','m','l'} | ||
178 | }, | ||
179 | {'d','m','l','h'}, | ||
180 | LILEND4(4), | ||
181 | LILEND4(frames) | ||
182 | } | ||
183 | } | ||
184 | }; | ||
185 | |||
186 | /* parsing command line arguments */ | ||
187 | if(argc<2) { | ||
188 | show_help(argc,argv); | ||
189 | return -1; | ||
190 | } | ||
191 | else if(argc==2 && strcmp(argv[1],"--version")==0) { | ||
192 | printf("jpegtoavi v%d.%d\n",VERSION_MAJ,VERSION_MIN); | ||
193 | return 0; | ||
194 | } | ||
195 | else if(argc<3) { | ||
196 | show_help(argc,argv); | ||
197 | return -1; | ||
198 | } | ||
199 | else if(strcmp(argv[1],"-fsz")==0) { | ||
200 | img0=2; | ||
201 | } | ||
202 | else if(strcmp(argv[1],"-f")==0) { | ||
203 | if(argc<6 || sscanf(argv[2],"%u",&fps)!=1 | ||
204 | || fps==0 | ||
205 | || sscanf(argv[3],"%u",&width)!=1 | ||
206 | || sscanf(argv[4],"%u",&height)!=1) { | ||
207 | show_help(argc,argv); | ||
208 | return -1; | ||
209 | } | ||
210 | else { | ||
211 | per_usec=1000000/fps; | ||
212 | img0=5; | ||
213 | } | ||
214 | } | ||
215 | else if(argc<5 || sscanf(argv[1],"%u",&per_usec)!=1 | ||
216 | || sscanf(argv[2],"%u",&width)!=1 | ||
217 | || sscanf(argv[3],"%u",&height)!=1) { | ||
218 | show_help(argc,argv); | ||
219 | return -1; | ||
220 | } | ||
221 | else { | ||
222 | img0=4; | ||
223 | } | ||
224 | frames=argc-img0; | ||
225 | |||
226 | /* getting image, riff sizes */ | ||
227 | if(img0!=2) { | ||
228 | if((szarray=(DWORD *)malloc(frames*sizeof(DWORD)))==0) { | ||
229 | fprintf(stderr,"malloc error"); | ||
230 | free(offsets); | ||
231 | return -5; | ||
232 | } | ||
233 | } | ||
234 | jpg_sz_64=img_array_sz(&argv[img0],frames,szarray); | ||
235 | if(jpg_sz_64==-1) { | ||
236 | fprintf(stderr,"couldn't determine size of images\n"); | ||
237 | return -2; | ||
238 | } | ||
239 | riff_sz_64=sizeof(struct AVI_list_hdrl)+4+4+jpg_sz_64 | ||
240 | +8*frames+8+8+16*frames; | ||
241 | if(riff_sz_64>=MAX_RIFF_SZ) { | ||
242 | fprintf(stderr,"RIFF would exceed 2 Gb limit\n"); | ||
243 | return -3; | ||
244 | } | ||
245 | jpg_sz=(long)jpg_sz_64; | ||
246 | riff_sz=(DWORD)riff_sz_64; | ||
247 | |||
248 | /* printing RIFF size and quitting */ | ||
249 | if(img0==2) { | ||
250 | printf("%lu\n",(unsigned long)riff_sz+8UL); | ||
251 | return 0; | ||
252 | } | ||
253 | |||
254 | /* printing AVI.. riff hdr */ | ||
255 | printf("RIFF"); | ||
256 | print_quartet(riff_sz); | ||
257 | printf("AVI "); | ||
258 | |||
259 | /* list hdrl */ | ||
260 | hdrl.avih.us_per_frame=LILEND4(per_usec); | ||
261 | hdrl.avih.max_bytes_per_sec=LILEND4(1000000*(jpg_sz/frames) | ||
262 | /per_usec); | ||
263 | hdrl.avih.tot_frames=LILEND4(frames); | ||
264 | hdrl.avih.width=LILEND4(width); | ||
265 | hdrl.avih.height=LILEND4(height); | ||
266 | hdrl.strl.strh.scale=LILEND4(per_usec); | ||
267 | hdrl.strl.strh.rate=LILEND4(1000000); | ||
268 | hdrl.strl.strh.length=LILEND4(frames); | ||
269 | hdrl.strl.strf.width=LILEND4(width); | ||
270 | hdrl.strl.strf.height=LILEND4(height); | ||
271 | hdrl.strl.strf.image_sz=LILEND4(width*height*3); | ||
272 | hdrl.strl.list_odml.frames=LILEND4(frames); | ||
273 | fwrite(&hdrl,sizeof(hdrl),1,stdout); | ||
274 | |||
275 | /* list movi */ | ||
276 | printf("LIST"); | ||
277 | print_quartet(jpg_sz+8*frames+4); | ||
278 | printf("movi"); | ||
279 | |||
280 | if((offsets=(DWORD *)malloc(frames*sizeof(DWORD)))==0) { | ||
281 | fprintf(stderr,"malloc error"); | ||
282 | return -4; | ||
283 | } | ||
284 | |||
285 | for(f=img0;f<argc;++f) { | ||
286 | printf("00db"); | ||
287 | mfsz=szarray[f-img0]; | ||
288 | remnant=(4-(mfsz%4))%4; | ||
289 | print_quartet(mfsz+remnant); | ||
290 | szarray[f-img0]+=remnant; | ||
291 | if(f==img0) { | ||
292 | offsets[0]=4; | ||
293 | } | ||
294 | else { | ||
295 | offsets[f-img0]=offsets[f-img0-1]+szarray[f-img0-1]+8; | ||
296 | } | ||
297 | if((fd=open(argv[f],O_RDONLY))<0) { | ||
298 | fprintf(stderr,"couldn't open file!\n"); | ||
299 | free(offsets); | ||
300 | free(szarray); | ||
301 | return -6; | ||
302 | } | ||
303 | nbw=0; | ||
304 | |||
305 | if((nbr=read(fd,buff,6))!=6) { | ||
306 | fprintf(stderr,"error\n"); | ||
307 | free(offsets); | ||
308 | free(szarray); | ||
309 | return -7; | ||
310 | } | ||
311 | fwrite(buff,nbr,1,stdout); | ||
312 | read(fd,buff,4); | ||
313 | fwrite("AVI1",4,1,stdout); | ||
314 | nbw=10; | ||
315 | |||
316 | while((nbr=read(fd,buff,512))>0) { | ||
317 | fwrite(buff,nbr,1,stdout); | ||
318 | nbw+=nbr; | ||
319 | } | ||
320 | if(remnant>0) { | ||
321 | fwrite(buff,remnant,1,stdout); | ||
322 | nbw+=remnant; | ||
323 | } | ||
324 | tnbw+=nbw; | ||
325 | close(fd); | ||
326 | } | ||
327 | if(tnbw!=jpg_sz) { | ||
328 | fprintf(stderr,"error writing images (wrote %ld bytes, expected %ld bytes)\n", | ||
329 | tnbw,jpg_sz); | ||
330 | free(offsets); | ||
331 | free(szarray); | ||
332 | return -8; | ||
333 | } | ||
334 | |||
335 | // indices | ||
336 | printf("idx1"); | ||
337 | print_quartet(16*frames); | ||
338 | for(f=0;f<frames;++f) { | ||
339 | printf("00db"); | ||
340 | print_quartet(18); | ||
341 | print_quartet(offsets[f]); | ||
342 | print_quartet(szarray[f]); | ||
343 | } | ||
344 | |||
345 | free(offsets); | ||
346 | free(szarray); | ||
347 | return 0; | ||
348 | } | ||
349 | |||