f8d1abc632e9c0bafb0a4652518489c3f8c167bc
[metze/wireshark/wip.git] / wiretap / mpeg.c
1 /* mpeg.c
2  *
3  * MPEG file format decoder for the Wiretap library.
4  * Written by Shaun Jackman <sjackman@gmail.com>
5  * Copyright 2007 Shaun Jackman
6  *
7  * $Id$
8  *
9  * Wiretap Library
10  * This program is free software; you can redistribute it and/or
11  * modify it under the terms of the GNU General Public License
12  * as published by the Free Software Foundation; either version 2
13  * of the License, or (at your option) any later version.
14  *
15  * This program 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
23  */
24
25 #include "config.h"
26
27 #ifdef HAVE_SYS_TYPES_H
28 #include <sys/types.h>
29 #endif
30
31 #ifdef HAVE_UNISTD_H
32 #include <unistd.h>
33 #endif
34
35 #include "mpeg.h"
36 #include "wsutil/mpeg-audio.h"
37
38 #include "wtap-int.h"
39 #include "buffer.h"
40 #include "file_wrappers.h"
41 #include <errno.h>
42 #include <stdlib.h>
43 #include <string.h>
44 #include <time.h>
45
46 #define PES_PREFIX 1
47 #define PES_VALID(n) (((n) >> 8 & 0xffffff) == PES_PREFIX)
48
49 typedef struct {
50         struct wtap_nstime now;
51         time_t t0;
52 } mpeg_t;
53
54 static int 
55 mpeg_resync(wtap *wth, int *err, gchar **err_info _U_)
56 {
57         gint64 offset = file_tell(wth->fh);
58         int count = 0;
59         int byte = file_getc(wth->fh);
60
61         while (byte != EOF) {
62                 if (byte == 0xff && count > 0) {
63                         byte = file_getc(wth->fh);
64                         if (byte != EOF && (byte & 0xe0) == 0xe0)
65                                 break;
66                 } else
67                         byte = file_getc(wth->fh);
68                 count++;
69         }
70         if (file_seek(wth->fh, offset, SEEK_SET, err) == -1)
71                 return 0;
72         return count;
73 }
74
75 static int 
76 mpeg_read_header(wtap *wth, int *err, gchar **err_info, guint32 *n)
77 {
78         int bytes_read;
79
80         errno = WTAP_ERR_CANT_READ;
81         bytes_read = file_read(n, sizeof *n, wth->fh);
82         if (bytes_read != sizeof *n) {
83                 *err = file_error(wth->fh, err_info);
84                 if (*err == 0 && bytes_read != 0)
85                         *err = WTAP_ERR_SHORT_READ;
86                 return -1;
87         }
88         *n = g_ntohl(*n);
89         if (file_seek(wth->fh, -(gint64)(sizeof *n), SEEK_CUR, err) == -1)
90                 return -1;
91         return bytes_read;
92 }
93
94 #define SCRHZ 27000000
95
96 static gboolean 
97 mpeg_read(wtap *wth, int *err, gchar **err_info, gint64 *data_offset)
98 {
99         mpeg_t *mpeg = (mpeg_t *)wth->priv;
100         guint32 n;
101         int bytes_read = mpeg_read_header(wth, err, err_info, &n);
102         unsigned int packet_size;
103         struct wtap_nstime ts = mpeg->now;
104
105         if (bytes_read == -1)
106                 return FALSE;
107         if (PES_VALID(n)) {
108                 gint64 offset = file_tell(wth->fh);
109                 guint8 stream;
110
111                 if (offset == -1)
112                         return -1;
113                 if (file_seek(wth->fh, 3, SEEK_CUR, err) == -1)
114                         return FALSE;
115
116                 bytes_read = file_read(&stream, sizeof stream, wth->fh);
117                 if (bytes_read != sizeof stream) {
118                         *err = file_error(wth->fh, err_info);
119                         return FALSE;
120                 }
121
122                 if (stream == 0xba) {
123                         guint32 pack1;
124                         guint32 pack0;
125                         guint64 pack;
126                         guint8 stuffing;
127
128                         bytes_read = file_read(&pack1, sizeof pack1, wth->fh);
129                         if (bytes_read != sizeof pack1) {
130                                 *err = file_error(wth->fh, err_info);
131                                 if (*err == 0 && bytes_read != 0)
132                                         *err = WTAP_ERR_SHORT_READ;
133                                 return FALSE;
134                         }
135                         bytes_read = file_read(&pack0, sizeof pack0, wth->fh);
136                         if (bytes_read != sizeof pack0) {
137                                 *err = file_error(wth->fh, err_info);
138                                 if (*err == 0 && bytes_read != 0)
139                                         *err = WTAP_ERR_SHORT_READ;
140                                 return FALSE;
141                         }
142                         pack = (guint64)g_ntohl(pack1) << 32 | g_ntohl(pack0);
143
144                         switch (pack >> 62) {
145                                 case 1:
146                                         if (file_seek(wth->fh, 1, SEEK_CUR, err) == -1)
147                                                 return FALSE;
148                                         bytes_read = file_read(&stuffing,
149                                                         sizeof stuffing, wth->fh);
150                                         if (bytes_read != sizeof stuffing) {
151                                                 *err = file_error(wth->fh, err_info);
152                                                 return FALSE;
153                                         }
154                                         stuffing &= 0x07;
155                                         packet_size = 14 + stuffing;
156
157                                         {
158                                                 guint64 bytes = pack >> 16;
159                                                 guint64 ts_val =
160                                                         (bytes >> 43 & 0x0007) << 30 |
161                                                         (bytes >> 27 & 0x7fff) << 15 |
162                                                         (bytes >> 11 & 0x7fff) << 0;
163                                                 guint ext = (guint)((bytes >> 1) & 0x1ff);
164                                                 guint64 cr = 300 * ts_val + ext;
165                                                 guint rem = (guint)(cr % SCRHZ);
166                                                 mpeg->now.secs
167                                                         = mpeg->t0 + (time_t)(cr / SCRHZ);
168                                                 mpeg->now.nsecs
169                                                         = (int)(G_GINT64_CONSTANT(1000000000) * rem / SCRHZ);
170                                         }
171                                         ts = mpeg->now;
172                                         break;
173                                 default:
174                                         packet_size = 12;
175                         }
176                 } else {
177                         guint16 length;
178                         bytes_read = file_read(&length, sizeof length, wth->fh);
179                         if (bytes_read != sizeof length) {
180                                 *err = file_error(wth->fh, err_info);
181                                 if (*err == 0 && bytes_read != 0)
182                                         *err = WTAP_ERR_SHORT_READ;
183                                 return FALSE;
184                         }
185                         length = g_ntohs(length);
186                         packet_size = 6 + length;
187                 }
188
189                 if (file_seek(wth->fh, offset, SEEK_SET, err) == -1)
190                         return FALSE;
191         } else {
192                 struct mpa mpa;
193
194                 MPA_UNMARSHAL(&mpa, n);
195                 if (MPA_VALID(&mpa)) {
196                         packet_size = MPA_BYTES(&mpa);
197                         mpeg->now.nsecs += MPA_DURATION_NS(&mpa);
198                         if (mpeg->now.nsecs >= 1000000000) {
199                                 mpeg->now.secs++;
200                                 mpeg->now.nsecs -= 1000000000;
201                         }
202                 } else {
203                         packet_size = mpeg_resync(wth, err, err_info);
204                         if (packet_size == 0)
205                                 return FALSE;
206                 }
207         }
208         *data_offset = file_tell(wth->fh);
209
210         if (!wtap_read_packet_bytes(wth->fh, wth->frame_buffer,
211                                 packet_size, err, err_info))
212                 return FALSE;
213         /* XXX - relative, not absolute, time stamps */
214         wth->phdr.presence_flags = WTAP_HAS_TS;
215         wth->phdr.ts = ts;
216         wth->phdr.caplen = packet_size;
217         wth->phdr.len = packet_size;
218         return TRUE;
219 }
220
221 static gboolean
222 mpeg_seek_read(wtap *wth, gint64 seek_off,
223                 struct wtap_pkthdr *phdr _U_, Buffer *buf, int length,
224                 int *err, gchar **err_info)
225 {
226         if (file_seek(wth->random_fh, seek_off, SEEK_SET, err) == -1)
227                 return FALSE;
228         return wtap_read_packet_bytes(wth->random_fh, buf, length, err, err_info);
229 }
230
231 struct _mpeg_magic {
232         size_t len;
233         const gchar* match;
234 } magic[] = {
235         { 3, "TAG" }, /* ID3v1 */
236         { 3, "ID3" }, /* ID3v2 */
237         { 3, "\0\0\1" }, /* MPEG PES */
238         { 2, "\xff\xfb" }, /* MP3, taken from http://en.wikipedia.org/wiki/MP3#File_structure */
239         { 0, NULL }
240 };
241
242 int 
243 mpeg_open(wtap *wth, int *err, gchar **err_info)
244 {
245         int bytes_read;
246         char magic_buf[16];
247         struct _mpeg_magic* m;
248         mpeg_t *mpeg;
249         
250         errno = WTAP_ERR_CANT_READ;
251         bytes_read = file_read(magic_buf, sizeof magic_buf, wth->fh);
252         if (bytes_read != (int) sizeof magic_buf) {
253                 *err = file_error(wth->fh, err_info);
254                 if (*err != 0 && *err != WTAP_ERR_SHORT_READ)
255                         return -1;
256                 return 0;
257         }
258
259         for (m=magic; m->match; m++) {
260                 if (memcmp(magic_buf, m->match, m->len) == 0)
261                         goto good_magic;
262         }
263         
264         return 0;
265
266 good_magic:
267         /* This appears to be a file with MPEG data. */
268         if (file_seek(wth->fh, 0, SEEK_SET, err) == -1)
269                 return -1;
270
271         wth->file_type = WTAP_FILE_MPEG;
272         wth->file_encap = WTAP_ENCAP_MPEG;
273         wth->tsprecision = WTAP_FILE_TSPREC_NSEC;
274         wth->subtype_read = mpeg_read;
275         wth->subtype_seek_read = mpeg_seek_read;
276         wth->snapshot_length = 0;
277
278         mpeg = (mpeg_t *)g_malloc(sizeof(mpeg_t));
279         wth->priv = (void *)mpeg;
280         mpeg->now.secs = 0;
281         mpeg->now.nsecs = 0;
282         mpeg->t0 = mpeg->now.secs;
283
284         return 1;
285 }