00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024 #include "config.h"
00025
00026 #include <stdio.h>
00027 #include <stdlib.h>
00028 #include <string.h>
00029 #include <errno.h>
00030 #include <signal.h>
00031 #include <getopt.h>
00032 #ifdef HAVE_IO_H
00033 #include <fcntl.h>
00034 #include <io.h>
00035 #endif
00036 #include <inttypes.h>
00037
00038 #include "mpeg2.h"
00039 #include "video_out.h"
00040 #include "convert.h"
00041 #include "gettimeofday.h"
00042
00043 #define BUFFER_SIZE 4096
00044 static uint8_t buffer[BUFFER_SIZE];
00045 static FILE * in_file;
00046 static int demux_track = 0;
00047 static int demux_pid = 0;
00048 static int demux_pva = 0;
00049 static mpeg2dec_t * mpeg2dec;
00050 static vo_open_t * output_open = NULL;
00051 static vo_instance_t * output;
00052
00053 #ifdef HAVE_GETTIMEOFDAY
00054
00055 static void print_fps (int final);
00056
00057 static RETSIGTYPE signal_handler (int sig)
00058 {
00059 print_fps (1);
00060 signal (sig, SIG_DFL);
00061 raise (sig);
00062 }
00063
00064 static void print_fps (int final)
00065 {
00066 static uint32_t frame_counter = 0;
00067 static struct timeval tv_beg, tv_start;
00068 static int total_elapsed;
00069 static int last_count = 0;
00070 struct timeval tv_end;
00071 float fps, tfps;
00072 int frames, elapsed;
00073
00074 gettimeofday (&tv_end, NULL);
00075
00076 if (!frame_counter) {
00077 tv_start = tv_beg = tv_end;
00078 signal (SIGINT, signal_handler);
00079 }
00080
00081 elapsed = (tv_end.tv_sec - tv_beg.tv_sec) * 100 +
00082 (tv_end.tv_usec - tv_beg.tv_usec) / 10000;
00083 total_elapsed = (tv_end.tv_sec - tv_start.tv_sec) * 100 +
00084 (tv_end.tv_usec - tv_start.tv_usec) / 10000;
00085
00086 if (final) {
00087 if (total_elapsed)
00088 tfps = frame_counter * 100.0 / total_elapsed;
00089 else
00090 tfps = 0;
00091
00092 fprintf (stderr,"\n%d frames decoded in %.2f seconds (%.2f fps)\n",
00093 frame_counter, total_elapsed / 100.0, tfps);
00094
00095 return;
00096 }
00097
00098 frame_counter++;
00099
00100 if (elapsed < 50)
00101 return;
00102
00103 tv_beg = tv_end;
00104 frames = frame_counter - last_count;
00105
00106 fps = frames * 100.0 / elapsed;
00107 tfps = frame_counter * 100.0 / total_elapsed;
00108
00109 fprintf (stderr, "%d frames in %.2f sec (%.2f fps), "
00110 "%d last %.2f sec (%.2f fps)\033[K\r", frame_counter,
00111 total_elapsed / 100.0, tfps, frames, elapsed / 100.0, fps);
00112
00113 last_count = frame_counter;
00114 }
00115
00116 #else
00117
00118 static void print_fps (int final)
00119 {
00120 }
00121
00122 #endif
00123
00124 static void print_usage (char ** argv)
00125 {
00126 int i;
00127 vo_driver_t * drivers;
00128
00129 fprintf (stderr, "usage: %s [-o <mode>] [-s [<track>]] [-t <pid>] [-p] "
00130 "[-c] <file>\n"
00131 "\t-s\tuse program stream demultiplexer, "
00132 "track 0-15 or 0xe0-0xef\n"
00133 "\t-t\tuse transport stream demultiplexer, pid 0x10-0x1ffe\n"
00134 "\t-p\tuse pva demultiplexer\n"
00135 "\t-c\tuse c implementation, disables all accelerations\n"
00136 "\t-o\tvideo output mode\n", argv[0]);
00137
00138 drivers = vo_drivers ();
00139 for (i = 0; drivers[i].name; i++)
00140 fprintf (stderr, "\t\t\t%s\n", drivers[i].name);
00141
00142 exit (1);
00143 }
00144
00145 static void handle_args (int argc, char ** argv)
00146 {
00147 int c;
00148 vo_driver_t * drivers;
00149 int i;
00150 char * s;
00151
00152 drivers = vo_drivers ();
00153 while ((c = getopt (argc, argv, "s::t:pco:")) != -1)
00154 switch (c) {
00155 case 'o':
00156 for (i = 0; drivers[i].name != NULL; i++)
00157 if (strcmp (drivers[i].name, optarg) == 0)
00158 output_open = drivers[i].open;
00159 if (output_open == NULL) {
00160 fprintf (stderr, "Invalid video driver: %s\n", optarg);
00161 print_usage (argv);
00162 }
00163 break;
00164
00165 case 's':
00166 demux_track = 0xe0;
00167 if (optarg != NULL) {
00168 demux_track = strtol (optarg, &s, 0);
00169 if (demux_track < 0xe0)
00170 demux_track += 0xe0;
00171 if ((demux_track < 0xe0) || (demux_track > 0xef) || (*s)) {
00172 fprintf (stderr, "Invalid track number: %s\n", optarg);
00173 print_usage (argv);
00174 }
00175 }
00176 break;
00177
00178 case 't':
00179 demux_pid = strtol (optarg, &s, 0);
00180 if ((demux_pid < 0x10) || (demux_pid > 0x1ffe) || (*s)) {
00181 fprintf (stderr, "Invalid pid: %s\n", optarg);
00182 print_usage (argv);
00183 }
00184 break;
00185
00186 case 'p':
00187 demux_pva = 1;
00188 break;
00189
00190 case 'c':
00191 mpeg2_accel (0);
00192 break;
00193
00194 default:
00195 print_usage (argv);
00196 }
00197
00198
00199 if (output_open == NULL)
00200 output_open = drivers[0].open;
00201
00202 if (optind < argc) {
00203 in_file = fopen (argv[optind], "rb");
00204 if (!in_file) {
00205 fprintf (stderr, "%s - could not open file %s\n", strerror (errno),
00206 argv[optind]);
00207 exit (1);
00208 }
00209 } else
00210 in_file = stdin;
00211 }
00212
00213 static void decode_mpeg2 (uint8_t * current, uint8_t * end)
00214 {
00215 const mpeg2_info_t * info;
00216 int state;
00217 vo_setup_result_t setup_result;
00218
00219 mpeg2_buffer (mpeg2dec, current, end);
00220
00221 info = mpeg2_info (mpeg2dec);
00222 while (1) {
00223 state = mpeg2_parse (mpeg2dec);
00224 switch (state) {
00225 case -1:
00226 return;
00227 case STATE_SEQUENCE:
00228
00229
00230 if (output->setup (output, info->sequence->width,
00231 info->sequence->height, &setup_result)) {
00232 fprintf (stderr, "display setup failed\n");
00233 exit (1);
00234 }
00235 if (setup_result.convert)
00236 mpeg2_convert (mpeg2dec, setup_result.convert, NULL);
00237 if (output->set_fbuf) {
00238 uint8_t * buf[3];
00239 void * id;
00240
00241 mpeg2_custom_fbuf (mpeg2dec, 1);
00242 output->set_fbuf (output, buf, &id);
00243 mpeg2_set_buf (mpeg2dec, buf, id);
00244 output->set_fbuf (output, buf, &id);
00245 mpeg2_set_buf (mpeg2dec, buf, id);
00246 } else if (output->setup_fbuf) {
00247 uint8_t * buf[3];
00248 void * id;
00249
00250 output->setup_fbuf (output, buf, &id);
00251 mpeg2_set_buf (mpeg2dec, buf, id);
00252 output->setup_fbuf (output, buf, &id);
00253 mpeg2_set_buf (mpeg2dec, buf, id);
00254 output->setup_fbuf (output, buf, &id);
00255 mpeg2_set_buf (mpeg2dec, buf, id);
00256 }
00257 break;
00258 case STATE_PICTURE:
00259
00260
00261 if (output->set_fbuf) {
00262 uint8_t * buf[3];
00263 void * id;
00264
00265 output->set_fbuf (output, buf, &id);
00266 mpeg2_set_buf (mpeg2dec, buf, id);
00267 }
00268 if (output->start_fbuf)
00269 output->start_fbuf (output, info->current_fbuf->buf,
00270 info->current_fbuf->id);
00271 break;
00272 case STATE_PICTURE_2ND:
00273
00274 break;
00275 case STATE_SLICE:
00276 case STATE_END:
00277
00278
00279 if (info->display_fbuf) {
00280 output->draw (output, info->display_fbuf->buf,
00281 info->display_fbuf->id);
00282 print_fps (0);
00283 }
00284 if (output->discard && info->discard_fbuf)
00285 output->discard (output, info->discard_fbuf->buf,
00286 info->discard_fbuf->id);
00287 break;
00288 }
00289 }
00290 }
00291
00292 #define DEMUX_PAYLOAD_START 1
00293 static int demux (uint8_t * buf, uint8_t * end, int flags)
00294 {
00295 static int mpeg1_skip_table[16] = {
00296 0, 0, 4, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
00297 };
00298
00299
00300
00301
00302
00303
00304
00305
00306
00307
00308
00309
00310
00311
00312
00313
00314
00315 #define DEMUX_HEADER 0
00316 #define DEMUX_DATA 1
00317 #define DEMUX_SKIP 2
00318 static int state = DEMUX_SKIP;
00319 static int state_bytes = 0;
00320 static uint8_t head_buf[264];
00321
00322 uint8_t * header;
00323 int bytes;
00324 int len;
00325
00326 #define NEEDBYTES(x) \
00327 do { \
00328 int missing; \
00329 \
00330 missing = (x) - bytes; \
00331 if (missing > 0) { \
00332 if (header == head_buf) { \
00333 if (missing <= end - buf) { \
00334 memcpy (header + bytes, buf, missing); \
00335 buf += missing; \
00336 bytes = (x); \
00337 } else { \
00338 memcpy (header + bytes, buf, end - buf); \
00339 state_bytes = bytes + end - buf; \
00340 return 0; \
00341 } \
00342 } else { \
00343 memcpy (head_buf, header, bytes); \
00344 state = DEMUX_HEADER; \
00345 state_bytes = bytes; \
00346 return 0; \
00347 } \
00348 } \
00349 } while (0)
00350
00351 #define DONEBYTES(x) \
00352 do { \
00353 if (header != head_buf) \
00354 buf = header + (x); \
00355 } while (0)
00356
00357 if (flags & DEMUX_PAYLOAD_START)
00358 goto payload_start;
00359 switch (state) {
00360 case DEMUX_HEADER:
00361 if (state_bytes > 0) {
00362 header = head_buf;
00363 bytes = state_bytes;
00364 goto continue_header;
00365 }
00366 break;
00367 case DEMUX_DATA:
00368 if (demux_pid || (state_bytes > end - buf)) {
00369 decode_mpeg2 (buf, end);
00370 state_bytes -= end - buf;
00371 return 0;
00372 }
00373 decode_mpeg2 (buf, buf + state_bytes);
00374 buf += state_bytes;
00375 break;
00376 case DEMUX_SKIP:
00377 if (demux_pid || (state_bytes > end - buf)) {
00378 state_bytes -= end - buf;
00379 return 0;
00380 }
00381 buf += state_bytes;
00382 break;
00383 }
00384
00385 while (1) {
00386 if (demux_pid) {
00387 state = DEMUX_SKIP;
00388 return 0;
00389 }
00390 payload_start:
00391 header = buf;
00392 bytes = end - buf;
00393 continue_header:
00394 NEEDBYTES (4);
00395 if (header[0] || header[1] || (header[2] != 1)) {
00396 if (demux_pid) {
00397 state = DEMUX_SKIP;
00398 return 0;
00399 } else if (header != head_buf) {
00400 buf++;
00401 goto payload_start;
00402 } else {
00403 header[0] = header[1];
00404 header[1] = header[2];
00405 header[2] = header[3];
00406 bytes = 3;
00407 goto continue_header;
00408 }
00409 }
00410 if (demux_pid) {
00411 if ((header[3] >= 0xe0) && (header[3] <= 0xef))
00412 goto pes;
00413 fprintf (stderr, "bad stream id %x\n", header[3]);
00414 exit (1);
00415 }
00416 switch (header[3]) {
00417 case 0xb9:
00418
00419
00420 return 1;
00421 case 0xba:
00422 NEEDBYTES (12);
00423 if ((header[4] & 0xc0) == 0x40) {
00424 NEEDBYTES (14);
00425 len = 14 + (header[13] & 7);
00426 NEEDBYTES (len);
00427 DONEBYTES (len);
00428
00429 } else if ((header[4] & 0xf0) == 0x20) {
00430 DONEBYTES (12);
00431
00432 } else {
00433 fprintf (stderr, "weird pack header\n");
00434 exit (1);
00435 }
00436 break;
00437 default:
00438 if (header[3] == demux_track) {
00439 pes:
00440 NEEDBYTES (7);
00441 if ((header[6] & 0xc0) == 0x80) {
00442 NEEDBYTES (9);
00443 len = 9 + header[8];
00444 NEEDBYTES (len);
00445
00446 if (header[7] & 0x80) {
00447 uint32_t pts;
00448
00449 pts = (((buf[9] >> 1) << 30) |
00450 (buf[10] << 22) | ((buf[11] >> 1) << 15) |
00451 (buf[12] << 7) | (buf[13] >> 1));
00452 mpeg2_pts (mpeg2dec, pts);
00453 }
00454 } else {
00455 int len_skip;
00456 uint8_t * ptsbuf;
00457
00458 len = 7;
00459 while (header[len - 1] == 0xff) {
00460 len++;
00461 NEEDBYTES (len);
00462 if (len > 23) {
00463 fprintf (stderr, "too much stuffing\n");
00464 break;
00465 }
00466 }
00467 if ((header[len - 1] & 0xc0) == 0x40) {
00468 len += 2;
00469 NEEDBYTES (len);
00470 }
00471 len_skip = len;
00472 len += mpeg1_skip_table[header[len - 1] >> 4];
00473 NEEDBYTES (len);
00474
00475 ptsbuf = header + len_skip;
00476 if (ptsbuf[-1] & 0x20) {
00477 uint32_t pts;
00478
00479 pts = (((ptsbuf[-1] >> 1) << 30) |
00480 (ptsbuf[0] << 22) | ((ptsbuf[1] >> 1) << 15) |
00481 (ptsbuf[2] << 7) | (ptsbuf[3] >> 1));
00482 mpeg2_pts (mpeg2dec, pts);
00483 }
00484 }
00485 DONEBYTES (len);
00486 bytes = 6 + (header[4] << 8) + header[5] - len;
00487 if (demux_pid || (bytes > end - buf)) {
00488 decode_mpeg2 (buf, end);
00489 state = DEMUX_DATA;
00490 state_bytes = bytes - (end - buf);
00491 return 0;
00492 } else if (bytes > 0) {
00493 decode_mpeg2 (buf, buf + bytes);
00494 buf += bytes;
00495 }
00496 } else if (header[3] < 0xb9) {
00497 fprintf (stderr,
00498 "looks like a video stream, not system stream\n");
00499 DONEBYTES (4);
00500 } else {
00501 NEEDBYTES (6);
00502 DONEBYTES (6);
00503 bytes = (header[4] << 8) + header[5];
00504 if (bytes > end - buf) {
00505 state = DEMUX_SKIP;
00506 state_bytes = bytes - (end - buf);
00507 return 0;
00508 }
00509 buf += bytes;
00510 }
00511 }
00512 }
00513 }
00514
00515 static void ps_loop (void)
00516 {
00517 uint8_t * end;
00518
00519 do {
00520 end = buffer + fread (buffer, 1, BUFFER_SIZE, in_file);
00521 if (demux (buffer, end, 0))
00522 break;
00523 } while (end == buffer + BUFFER_SIZE);
00524 }
00525
00526 static int pva_demux (uint8_t * buf, uint8_t * end)
00527 {
00528 static int state = DEMUX_SKIP;
00529 static int state_bytes = 0;
00530 static uint8_t head_buf[12];
00531
00532 uint8_t * header;
00533 int bytes;
00534 int len;
00535
00536 switch (state) {
00537 case DEMUX_HEADER:
00538 if (state_bytes > 0) {
00539 header = head_buf;
00540 bytes = state_bytes;
00541 goto continue_header;
00542 }
00543 break;
00544 case DEMUX_DATA:
00545 if (state_bytes > end - buf) {
00546 decode_mpeg2 (buf, end);
00547 state_bytes -= end - buf;
00548 return 0;
00549 }
00550 decode_mpeg2 (buf, buf + state_bytes);
00551 buf += state_bytes;
00552 break;
00553 case DEMUX_SKIP:
00554 if (state_bytes > end - buf) {
00555 state_bytes -= end - buf;
00556 return 0;
00557 }
00558 buf += state_bytes;
00559 break;
00560 }
00561
00562 while (1) {
00563 payload_start:
00564 header = buf;
00565 bytes = end - buf;
00566 continue_header:
00567 NEEDBYTES (2);
00568 if (header[0] != 0x41 || header[1] != 0x56) {
00569 if (header != head_buf) {
00570 buf++;
00571 goto payload_start;
00572 } else {
00573 header[0] = header[1];
00574 bytes = 1;
00575 goto continue_header;
00576 }
00577 }
00578 NEEDBYTES (8);
00579 if (header[2] != 1) {
00580 DONEBYTES (8);
00581 bytes = (header[6] << 8) + header[7];
00582 if (bytes > end - buf) {
00583 state = DEMUX_SKIP;
00584 state_bytes = bytes - (end - buf);
00585 return 0;
00586 }
00587 buf += bytes;
00588 } else {
00589 len = 8;
00590 if (header[5] & 0x10) {
00591 len = 12 + (header[5] & 3);
00592 NEEDBYTES (len);
00593 decode_mpeg2 (header + 12, header + len);
00594 mpeg2_pts (mpeg2dec, ((header[8] << 24) | (header[9] << 16) |
00595 (header[10] << 8) | header[11]));
00596 }
00597 DONEBYTES (len);
00598 bytes = (header[6] << 8) + header[7] + 8 - len;
00599 if (bytes > end - buf) {
00600 decode_mpeg2 (buf, end);
00601 state = DEMUX_DATA;
00602 state_bytes = bytes - (end - buf);
00603 return 0;
00604 } else if (bytes > 0) {
00605 decode_mpeg2 (buf, buf + bytes);
00606 buf += bytes;
00607 }
00608 }
00609 }
00610 }
00611
00612 static void pva_loop (void)
00613 {
00614 uint8_t * end;
00615
00616 do {
00617 end = buffer + fread (buffer, 1, BUFFER_SIZE, in_file);
00618 pva_demux (buffer, end);
00619 } while (end == buffer + BUFFER_SIZE);
00620 }
00621
00622 static void ts_loop (void)
00623 {
00624 #define PACKETS (BUFFER_SIZE / 188)
00625 uint8_t * buf;
00626 uint8_t * data;
00627 uint8_t * end;
00628 int packets;
00629 int i;
00630 int pid;
00631
00632 do {
00633 packets = fread (buffer, 188, PACKETS, in_file);
00634 for (i = 0; i < packets; i++) {
00635 buf = buffer + i * 188;
00636 end = buf + 188;
00637 if (buf[0] != 0x47) {
00638 fprintf (stderr, "bad sync byte\n");
00639 exit (1);
00640 }
00641 pid = ((buf[1] << 8) + buf[2]) & 0x1fff;
00642 if (pid != demux_pid)
00643 continue;
00644 data = buf + 4;
00645 if (buf[3] & 0x20) {
00646 data = buf + 5 + buf[4];
00647 if (data > end)
00648 continue;
00649 }
00650 if (buf[3] & 0x10)
00651 demux (data, end, (buf[1] & 0x40) ? DEMUX_PAYLOAD_START : 0);
00652 }
00653 } while (packets == PACKETS);
00654 }
00655
00656 static void es_loop (void)
00657 {
00658 uint8_t * end;
00659
00660 do {
00661 end = buffer + fread (buffer, 1, BUFFER_SIZE, in_file);
00662 decode_mpeg2 (buffer, end);
00663 } while (end == buffer + BUFFER_SIZE);
00664 }
00665
00666 int main (int argc, char ** argv)
00667 {
00668 #ifdef HAVE_IO_H
00669 setmode (fileno (stdout), O_BINARY);
00670 #endif
00671
00672 fprintf (stderr, PACKAGE"-"VERSION
00673 " - by Michel Lespinasse <walken@zoy.org> and Aaron Holtzman\n");
00674
00675 handle_args (argc, argv);
00676
00677 output = output_open ();
00678 if (output == NULL) {
00679 fprintf (stderr, "Can not open output\n");
00680 return 1;
00681 }
00682 mpeg2dec = mpeg2_init ();
00683 if (mpeg2dec == NULL)
00684 exit (1);
00685
00686 if (demux_pva)
00687 pva_loop ();
00688 else if (demux_pid)
00689 ts_loop ();
00690 else if (demux_track)
00691 ps_loop ();
00692 else
00693 es_loop ();
00694
00695 mpeg2_close (mpeg2dec);
00696 if (output->close)
00697 output->close (output);
00698 print_fps (1);
00699 return 0;
00700 }