vobsub.c

   1 /*
   2  * Some code freely inspired from VobSub <URL:http://vobsub.edensrising.com>,
   3  * with kind permission from Gabest <gabest@freemail.hu>
   4  */
   5 #include <ctype.h>
   6 #include <errno.h>
   7 #include <limits.h>
   8 #include <stddef.h>
   9 #include <stdio.h>
  10 #include <stdlib.h>
  11 #include <string.h>
  12 #include <fcntl.h>
  13 #include <unistd.h>
  14 #include <sys/stat.h>
  15 #include <sys/types.h>
  16
  17 #include "config.h"
  18 #include "version.h"
  19
  20 #include "vobsub.h"
  21 #include "spudec.h"
  22 #include "mp_msg.h"
  23 #ifdef USE_UNRARLIB
  24 #include "unrarlib.h"
  25 #endif
  26 #include "libavutil/common.h"
  27
  28 extern int vobsub_id;
  29
  30 /**********************************************************************
  31  * RAR stream handling
  32  * The RAR file must have the same basename as the file to open
  33  * See <URL:http://www.unrarlib.org/>
  34  **********************************************************************/
  35 #ifdef USE_UNRARLIB
  36 typedef struct {
  37     FILE *file;
  38     unsigned char *data;
  39     unsigned long size;
  40     unsigned long pos;
  41 } rar_stream_t;
  42 static rar_stream_t *
  43 rar_open(const char *const filename, const char *const mode)
  44 {
  45     rar_stream_t *stream;
  46     /* unrarlib can only read */
  47     if (strcmp("r", mode) && strcmp("rb", mode)) {
  48         errno = EINVAL;
  49         return NULL;
  50     }
  51     stream = malloc(sizeof(rar_stream_t));
  52     if (stream == NULL)
  53         return NULL;
  54     /* first try normal access */
  55     stream->file = fopen(filename, mode);
  56     if (stream->file == NULL) {
  57         char *rar_filename;
  58         const char *p;
  59         int rc;
  60         /* Guess the RAR archive filename */
  61         rar_filename = NULL;
  62         p = strrchr(filename, '.');
  63         if (p) {
  64             ptrdiff_t l = p - filename;
  65             rar_filename = malloc(l + 5);
  66             if (rar_filename == NULL) {
  67                 free(stream);
  68                 return NULL;
  69             }
  70             strncpy(rar_filename, filename, l);
  71             strcpy(rar_filename + l, ".rar");
  72         }
  73         else {
  74             rar_filename = malloc(strlen(filename) + 5);
  75             if (rar_filename == NULL) {
  76                 free(stream);
  77                 return NULL;
  78             }
  79             strcpy(rar_filename, filename);
  80             strcat(rar_filename, ".rar");
  81         }
  82         /* get rid of the path if there is any */
  83         if ((p = strrchr(filename, '/')) == NULL) {
  84                 p = filename;
  85         } else {
  86                 p++;
  87         }
  88         rc = urarlib_get(&stream->data, &stream->size, (char*) p, rar_filename, "");
  89         if (!rc) {
  90             /* There is no matching filename in the archive. However, sometimes
  91              * the files we are looking for have been given arbitrary names in the archive.
  92              * Let's look for a file with an exact match in the extension only. */
  93             int i, num_files, name_len;
  94             ArchiveList_struct *list, *lp;
  95             /* the cast in the next line is a hack to overcome a design flaw (IMHO) in unrarlib */
  96             num_files = urarlib_list (rar_filename, (ArchiveList_struct *)&list);
  97             if (num_files > 0) {
  98                 char *demanded_ext;
  99                 demanded_ext = strrchr (p, '.');
 100                 if (demanded_ext) {
 101                     int demanded_ext_len = strlen (demanded_ext);
 102                     for (i=0, lp=list; i<num_files; i++, lp=lp->next) {
 103                         name_len = strlen (lp->item.Name);
 104                         if (name_len >= demanded_ext_len && !strcasecmp (lp->item.Name + name_len - demanded_ext_len, demanded_ext)) {
 105                             if ((rc = urarlib_get(&stream->data, &stream->size, lp->item.Name, rar_filename, ""))) {
 106                                 break;
 107                             }
 108                         }
 109                     }
 110                 }
 111                 urarlib_freelist (list);
 112             }
 113             if (!rc) {
 114                 free(rar_filename);
 115                 free(stream);
 116                 return NULL;
 117             }
 118         }
 119
 120         free(rar_filename);
 121         stream->pos = 0;
 122     }
 123     return stream;
 124 }
 125
 126 static int
 127 rar_close(rar_stream_t *stream)
 128 {
 129     if (stream->file)
 130         return fclose(stream->file);
 131     free(stream->data);
 132     return 0;
 133 }
 134
 135 static int
 136 rar_eof(rar_stream_t *stream)
 137 {
 138     if (stream->file)
 139         return feof(stream->file);
 140     return stream->pos >= stream->size;
 141 }
 142
 143 static long
 144 rar_tell(rar_stream_t *stream)
 145 {
 146     if (stream->file)
 147         return ftell(stream->file);
 148     return stream->pos;
 149 }
 150
 151 static int
 152 rar_seek(rar_stream_t *stream, long offset, int whence)
 153 {
 154     if (stream->file)
 155         return fseek(stream->file, offset, whence);
 156     switch (whence) {
 157     case SEEK_SET:
 158         if (offset < 0) {
 159             errno = EINVAL;
 160             return -1;
 161         }
 162         stream->pos = offset;
 163         break;
 164     case SEEK_CUR:
 165         if (offset < 0 && stream->pos < (unsigned long) -offset) {
 166             errno = EINVAL;
 167             return -1;
 168         }
 169         stream->pos += offset;
 170         break;
 171     case SEEK_END:
 172         if (offset < 0 && stream->size < (unsigned long) -offset) {
 173             errno = EINVAL;
 174             return -1;
 175         }
 176         stream->pos = stream->size + offset;
 177         break;
 178     default:
 179         errno = EINVAL;
 180         return -1;
 181     }
 182     return 0;
 183 }
 184
 185 static int
 186 rar_getc(rar_stream_t *stream)
 187 {
 188     if (stream->file)
 189         return getc(stream->file);
 190     if (rar_eof(stream))
 191         return EOF;
 192     return stream->data[stream->pos++];
 193 }
 194
 195 static size_t
 196 rar_read(void *ptr, size_t size, size_t nmemb, rar_stream_t *stream)
 197 {
 198     size_t res;
 199     unsigned long remain;
 200     if (stream->file)
 201         return fread(ptr, size, nmemb, stream->file);
 202     if (rar_eof(stream))
 203         return 0;
 204     res = size * nmemb;
 205     remain = stream->size - stream->pos;
 206     if (res > remain)
 207         res = remain / size * size;
 208     memcpy(ptr, stream->data + stream->pos, res);
 209     stream->pos += res;
 210     res /= size;
 211     return res;
 212 }
 213
 214 #else
 215 typedef FILE rar_stream_t;
 216 #define rar_open        fopen
 217 #define rar_close       fclose
 218 #define rar_eof         feof
 219 #define rar_tell        ftell
 220 #define rar_seek        fseek
 221 #define rar_getc        getc
 222 #define rar_read        fread
 223 #endif
 224
 225 /**********************************************************************/
 226
 227 static ssize_t
 228 vobsub_getline(char **lineptr, size_t *n, rar_stream_t *stream)
 229 {
 230     size_t res = 0;
 231     int c;
 232     if (*lineptr == NULL) {
 233         *lineptr = malloc(4096);
 234         if (*lineptr)
 235             *n = 4096;
 236     }
 237     else if (*n == 0) {
 238         char *tmp = realloc(*lineptr, 4096);
 239         if (tmp) {
 240             *lineptr = tmp;
 241             *n = 4096;
 242         }
 243     }
 244     if (*lineptr == NULL || *n == 0)
 245         return -1;
 246
 247     for (c = rar_getc(stream); c != EOF; c = rar_getc(stream)) {
 248         if (res + 1 >= *n) {
 249             char *tmp = realloc(*lineptr, *n * 2);
 250             if (tmp == NULL)
 251                 return -1;
 252             *lineptr = tmp;
 253             *n *= 2;
 254         }
 255         (*lineptr)[res++] = c;
 256         if (c == '\n') {
 257             (*lineptr)[res] = 0;
 258             return res;
 259         }
 260     }
 261     if (res == 0)
 262         return -1;
 263     (*lineptr)[res] = 0;
 264     return res;
 265 }
 266
 267 /**********************************************************************
 268  * MPEG parsing
 269  **********************************************************************/
 270
 271 typedef struct {
 272     rar_stream_t *stream;
 273     unsigned int pts;
 274     int aid;
 275     unsigned char *packet;
 276     unsigned int packet_reserve;
 277     unsigned int packet_size;
 278 } mpeg_t;
 279
 280 static mpeg_t *
 281 mpeg_open(const char *filename)
 282 {
 283     mpeg_t *res = malloc(sizeof(mpeg_t));
 284     int err = res == NULL;
 285     if (!err) {
 286         res->pts = 0;
 287         res->aid = -1;
 288         res->packet = NULL;
 289         res->packet_size = 0;
 290         res->packet_reserve = 0;
 291         res->stream = rar_open(filename, "rb");
 292         err = res->stream == NULL;
 293         if (err)
 294             perror("fopen Vobsub file failed");
 295         if (err)
 296             free(res);
 297     }
 298     return err ? NULL : res;
 299 }
 300
 301 static void
 302 mpeg_free(mpeg_t *mpeg)
 303 {
 304     if (mpeg->packet)
 305         free(mpeg->packet);
 306     if (mpeg->stream)
 307         rar_close(mpeg->stream);
 308     free(mpeg);
 309 }
 310
 311 static int
 312 mpeg_eof(mpeg_t *mpeg)
 313 {
 314     return rar_eof(mpeg->stream);
 315 }
 316
 317 static off_t
 318 mpeg_tell(mpeg_t *mpeg)
 319 {
 320     return rar_tell(mpeg->stream);
 321 }
 322
 323 static int
 324 mpeg_run(mpeg_t *mpeg)
 325 {
 326     unsigned int len, idx, version;
 327     int c;
 328     /* Goto start of a packet, it starts with 0x000001?? */
 329     const unsigned char wanted[] = { 0, 0, 1 };
 330     unsigned char buf[5];
 331
 332     mpeg->aid = -1;
 333     mpeg->packet_size = 0;
 334     if (rar_read(buf, 4, 1, mpeg->stream) != 1)
 335         return -1;
 336     while (memcmp(buf, wanted, sizeof(wanted)) != 0) {
 337         c = rar_getc(mpeg->stream);
 338         if (c < 0)
 339             return -1;
 340         memmove(buf, buf + 1, 3);
 341         buf[3] = c;
 342     }
 343     switch (buf[3]) {
 344     case 0xb9:                  /* System End Code */
 345         break;
 346     case 0xba:                  /* Packet start code */
 347         c = rar_getc(mpeg->stream);
 348         if (c < 0)
 349             return -1;
 350         if ((c & 0xc0) == 0x40)
 351             version = 4;
 352         else if ((c & 0xf0) == 0x20)
 353             version = 2;
 354         else {
 355             mp_msg(MSGT_VOBSUB,MSGL_ERR, "VobSub: Unsupported MPEG version: 0x%02x\n", c);
 356             return -1;
 357         }
 358         if (version == 4) {
 359             if (rar_seek(mpeg->stream, 9, SEEK_CUR))
 360                 return -1;
 361         }
 362         else if (version == 2) {
 363             if (rar_seek(mpeg->stream, 7, SEEK_CUR))
 364                 return -1;
 365         }
 366         else
 367             abort();
 368         break;
 369     case 0xbd:                  /* packet */
 370         if (rar_read(buf, 2, 1, mpeg->stream) != 1)
 371             return -1;
 372         len = buf[0] << 8 | buf[1];
 373         idx = mpeg_tell(mpeg);
 374         c = rar_getc(mpeg->stream);
 375         if (c < 0)
 376             return -1;
 377         if ((c & 0xC0) == 0x40) { /* skip STD scale & size */
 378             if (rar_getc(mpeg->stream) < 0)
 379                 return -1;
 380             c = rar_getc(mpeg->stream);
 381             if (c < 0)
 382                 return -1;
 383         }
 384         if ((c & 0xf0) == 0x20) { /* System-1 stream timestamp */
 385             /* Do we need this? */
 386             abort();
 387         }
 388         else if ((c & 0xf0) == 0x30) {
 389             /* Do we need this? */
 390             abort();
 391         }
 392         else if ((c & 0xc0) == 0x80) { /* System-2 (.VOB) stream */
 393             unsigned int pts_flags, hdrlen, dataidx;
 394             c = rar_getc(mpeg->stream);
 395             if (c < 0)
 396                 return -1;
 397             pts_flags = c;
 398             c = rar_getc(mpeg->stream);
 399             if (c < 0)
 400                 return -1;
 401             hdrlen = c;
 402             dataidx = mpeg_tell(mpeg) + hdrlen;
 403             if (dataidx > idx + len) {
 404                 mp_msg(MSGT_VOBSUB,MSGL_ERR, "Invalid header length: %d (total length: %d, idx: %d, dataidx: %d)\n",
 405                         hdrlen, len, idx, dataidx);
 406                 return -1;
 407             }
 408             if ((pts_flags & 0xc0) == 0x80) {
 409                 if (rar_read(buf, 5, 1, mpeg->stream) != 1)
 410                     return -1;
 411                 if (!(((buf[0] & 0xf0) == 0x20) && (buf[0] & 1) && (buf[2] & 1) &&  (buf[4] & 1))) {
 412                     mp_msg(MSGT_VOBSUB,MSGL_ERR, "vobsub PTS error: 0x%02x %02x%02x %02x%02x \n",
 413                             buf[0], buf[1], buf[2], buf[3], buf[4]);
 414                     mpeg->pts = 0;
 415                 }
 416                 else
 417                     mpeg->pts = ((buf[0] & 0x0e) << 29 | buf[1] << 22 | (buf[2] & 0xfe) << 14
 418                         | buf[3] << 7 | (buf[4] >> 1));
 419             }
 420             else /* if ((pts_flags & 0xc0) == 0xc0) */ {
 421                 /* what's this? */
 422                 /* abort(); */
 423             }
 424             rar_seek(mpeg->stream, dataidx, SEEK_SET);
 425             mpeg->aid = rar_getc(mpeg->stream);
 426             if (mpeg->aid < 0) {
 427                 mp_msg(MSGT_VOBSUB,MSGL_ERR, "Bogus aid %d\n", mpeg->aid);
 428                 return -1;
 429             }
 430             mpeg->packet_size = len - ((unsigned int) mpeg_tell(mpeg) - idx);
 431             if (mpeg->packet_reserve < mpeg->packet_size) {
 432                 if (mpeg->packet)
 433                     free(mpeg->packet);
 434                 mpeg->packet = malloc(mpeg->packet_size);
 435                 if (mpeg->packet)
 436                     mpeg->packet_reserve = mpeg->packet_size;
 437             }
 438             if (mpeg->packet == NULL) {
 439                 mp_msg(MSGT_VOBSUB,MSGL_FATAL,"malloc failure");
 440                 mpeg->packet_reserve = 0;
 441                 mpeg->packet_size = 0;
 442                 return -1;
 443             }
 444             if (rar_read(mpeg->packet, mpeg->packet_size, 1, mpeg->stream) != 1) {
 445                 mp_msg(MSGT_VOBSUB,MSGL_ERR,"fread failure");
 446                 mpeg->packet_size = 0;
 447                 return -1;
 448             }
 449             idx = len;
 450         }
 451         break;
 452     case 0xbe:                  /* Padding */
 453         if (rar_read(buf, 2, 1, mpeg->stream) != 1)
 454             return -1;
 455         len = buf[0] << 8 | buf[1];
 456         if (len > 0 && rar_seek(mpeg->stream, len, SEEK_CUR))
 457             return -1;
 458         break;
 459     default:
 460         if (0xc0 <= buf[3] && buf[3] < 0xf0) {
 461             /* MPEG audio or video */
 462             if (rar_read(buf, 2, 1, mpeg->stream) != 1)
 463                 return -1;
 464             len = buf[0] << 8 | buf[1];
 465             if (len > 0 && rar_seek(mpeg->stream, len, SEEK_CUR))
 466                 return -1;
 467
 468         }
 469         else {
 470             mp_msg(MSGT_VOBSUB,MSGL_ERR,"unknown header 0x%02X%02X%02X%02X\n",
 471                     buf[0], buf[1], buf[2], buf[3]);
 472             return -1;
 473         }
 474     }
 475     return 0;
 476 }
 477
 478 /**********************************************************************
 479  * Packet queue
 480  **********************************************************************/
 481
 482 typedef struct {
 483     unsigned int pts100;
 484     off_t filepos;
 485     unsigned int size;
 486     unsigned char *data;
 487 } packet_t;
 488
 489 typedef struct {
 490     char *id;
 491     packet_t *packets;
 492     unsigned int packets_reserve;
 493     unsigned int packets_size;
 494     unsigned int current_index;
 495 } packet_queue_t;
 496
 497 static void
 498 packet_construct(packet_t *pkt)
 499 {
 500     pkt->pts100 = 0;
 501     pkt->filepos = 0;
 502     pkt->size = 0;
 503     pkt->data = NULL;
 504 }
 505
 506 static void
 507 packet_destroy(packet_t *pkt)
 508 {
 509     if (pkt->data)
 510         free(pkt->data);
 511 }
 512
 513 static void
 514 packet_queue_construct(packet_queue_t *queue)
 515 {
 516     queue->id = NULL;
 517     queue->packets = NULL;
 518     queue->packets_reserve = 0;
 519     queue->packets_size = 0;
 520     queue->current_index = 0;
 521 }
 522
 523 static void
 524 packet_queue_destroy(packet_queue_t *queue)
 525 {
 526     if (queue->packets) {
 527         while (queue->packets_size--)
 528             packet_destroy(queue->packets + queue->packets_size);
 529         free(queue->packets);
 530     }
 531     return;
 532 }
 533
 534 /* Make sure there is enough room for needed_size packets in the
 535    packet queue. */
 536 static int
 537 packet_queue_ensure(packet_queue_t *queue, unsigned int needed_size)
 538 {
 539     if (queue->packets_reserve < needed_size) {
 540         if (queue->packets) {
 541             packet_t *tmp = realloc(queue->packets, 2 * queue->packets_reserve * sizeof(packet_t));
 542             if (tmp == NULL) {
 543                 mp_msg(MSGT_VOBSUB,MSGL_FATAL,"realloc failure");
 544                 return -1;
 545             }
 546             queue->packets = tmp;
 547             queue->packets_reserve *= 2;
 548         }
 549         else {
 550             queue->packets = malloc(sizeof(packet_t));
 551             if (queue->packets == NULL) {
 552                 mp_msg(MSGT_VOBSUB,MSGL_FATAL,"malloc failure");
 553                 return -1;
 554             }
 555             queue->packets_reserve = 1;
 556         }
 557     }
 558     return 0;
 559 }
 560
 561 /* add one more packet */
 562 static int
 563 packet_queue_grow(packet_queue_t *queue)
 564 {
 565     if (packet_queue_ensure(queue, queue->packets_size + 1) < 0)
 566         return -1;
 567     packet_construct(queue->packets + queue->packets_size);
 568     ++queue->packets_size;
 569     return 0;
 570 }
 571
 572 /* insert a new packet, duplicating pts from the current one */
 573 static int
 574 packet_queue_insert(packet_queue_t *queue)
 575 {
 576     packet_t *pkts;
 577     if (packet_queue_ensure(queue, queue->packets_size + 1) < 0)
 578         return -1;
 579     /* XXX packet_size does not reflect the real thing here, it will be updated a bit later */
 580     memmove(queue->packets + queue->current_index + 2,
 581             queue->packets + queue->current_index + 1,
 582             sizeof(packet_t) * (queue->packets_size - queue->current_index - 1));
 583     pkts = queue->packets + queue->current_index;
 584     ++queue->packets_size;
 585     ++queue->current_index;
 586     packet_construct(pkts + 1);
 587     pkts[1].pts100 = pkts[0].pts100;
 588     pkts[1].filepos = pkts[0].filepos;
 589     return 0;
 590 }
 591
 592 /**********************************************************************
 593  * Vobsub
 594  **********************************************************************/
 595
 596 typedef struct {
 597     unsigned int palette[16];
 598     unsigned int cuspal[4];
 599     int delay;
 600     unsigned int custom;
 601     unsigned int have_palette;
 602     unsigned int orig_frame_width, orig_frame_height;
 603     unsigned int origin_x, origin_y;
 604     unsigned int forced_subs;
 605     /* index */
 606     packet_queue_t *spu_streams;
 607     unsigned int spu_streams_size;
 608     unsigned int spu_streams_current;
 609 } vobsub_t;
 610
 611 /* Make sure that the spu stream idx exists. */
 612 static int
 613 vobsub_ensure_spu_stream(vobsub_t *vob, unsigned int index)
 614 {
 615     if (index >= vob->spu_streams_size) {
 616         /* This is a new stream */
 617         if (vob->spu_streams) {
 618             packet_queue_t *tmp = realloc(vob->spu_streams, (index + 1) * sizeof(packet_queue_t));
 619             if (tmp == NULL) {
 620                 mp_msg(MSGT_VOBSUB,MSGL_ERR,"vobsub_ensure_spu_stream: realloc failure");
 621                 return -1;
 622             }
 623             vob->spu_streams = tmp;
 624         }
 625         else {
 626             vob->spu_streams = malloc((index + 1) * sizeof(packet_queue_t));
 627             if (vob->spu_streams == NULL) {
 628                 mp_msg(MSGT_VOBSUB,MSGL_ERR,"vobsub_ensure_spu_stream: malloc failure");
 629                 return -1;
 630             }
 631         }
 632         while (vob->spu_streams_size <= index) {
 633             packet_queue_construct(vob->spu_streams + vob->spu_streams_size);
 634             ++vob->spu_streams_size;
 635         }
 636     }
 637     return 0;
 638 }
 639
 640 static int
 641 vobsub_add_id(vobsub_t *vob, const char *id, size_t idlen, const unsigned int index)
 642 {
 643     if (vobsub_ensure_spu_stream(vob, index) < 0)
 644         return -1;
 645     if (id && idlen) {
 646         if (vob->spu_streams[index].id)
 647             free(vob->spu_streams[index].id);
 648         vob->spu_streams[index].id = malloc(idlen + 1);
 649         if (vob->spu_streams[index].id == NULL) {
 650             mp_msg(MSGT_VOBSUB,MSGL_FATAL,"vobsub_add_id: malloc failure");
 651             return -1;
 652         }
 653         vob->spu_streams[index].id[idlen] = 0;
 654         memcpy(vob->spu_streams[index].id, id, idlen);
 655     }
 656     vob->spu_streams_current = index;
 657     mp_msg(MSGT_IDENTIFY, MSGL_INFO, "ID_VOBSUB_ID=%d\n", index);
 658     if (id && idlen)
 659         mp_msg(MSGT_IDENTIFY, MSGL_INFO, "ID_VSID_%d_LANG=%s\n", index, vob->spu_streams[index].id);
 660     mp_msg(MSGT_VOBSUB,MSGL_V,"[vobsub] subtitle (vobsubid): %d language %s\n",
 661                 index, vob->spu_streams[index].id);
 662     return 0;
 663 }
 664
 665 static int
 666 vobsub_add_timestamp(vobsub_t *vob, off_t filepos, int ms)
 667 {
 668     packet_queue_t *queue;
 669     packet_t *pkt;
 670     if (vob->spu_streams == 0) {
 671         mp_msg(MSGT_VOBSUB,MSGL_WARN,"[vobsub] warning, binning some index entries.  Check your index file\n");
 672         return -1;
 673     }
 674     queue = vob->spu_streams + vob->spu_streams_current;
 675     if (packet_queue_grow(queue) >= 0) {
 676         pkt = queue->packets + (queue->packets_size - 1);
 677         pkt->filepos = filepos;
 678         pkt->pts100 = ms < 0 ? UINT_MAX : (unsigned int)ms * 90;
 679         return 0;
 680     }
 681     return -1;
 682 }
 683
 684 static int
 685 vobsub_parse_id(vobsub_t *vob, const char *line)
 686 {
 687     // id: xx, index: n
 688     size_t idlen;
 689     const char *p, *q;
 690     p  = line;
 691     while (isspace(*p))
 692         ++p;
 693     q = p;
 694     while (isalpha(*q))
 695         ++q;
 696     idlen = q - p;
 697     if (idlen == 0)
 698         return -1;
 699     ++q;
 700     while (isspace(*q))
 701         ++q;
 702     if (strncmp("index:", q, 6))
 703         return -1;
 704     q += 6;
 705     while (isspace(*q))
 706         ++q;
 707     if (!isdigit(*q))
 708         return -1;
 709     return vobsub_add_id(vob, p, idlen, atoi(q));
 710 }
 711
 712 static int
 713 vobsub_parse_timestamp(vobsub_t *vob, const char *line)
 714 {
 715     // timestamp: HH:MM:SS.mmm, filepos: 0nnnnnnnnn
 716     const char *p;
 717     int h, m, s, ms;
 718     off_t filepos;
 719     while (isspace(*line))
 720         ++line;
 721     p = line;
 722     while (isdigit(*p))
 723         ++p;
 724     if (p - line != 2)
 725         return -1;
 726     h = atoi(line);
 727     if (*p != ':')
 728         return -1;
 729     line = ++p;
 730     while (isdigit(*p))
 731         ++p;
 732     if (p - line != 2)
 733         return -1;
 734     m = atoi(line);
 735     if (*p != ':')
 736         return -1;
 737     line = ++p;
 738     while (isdigit(*p))
 739         ++p;
 740     if (p - line != 2)
 741         return -1;
 742     s = atoi(line);
 743     if (*p != ':')
 744         return -1;
 745     line = ++p;
 746     while (isdigit(*p))
 747         ++p;
 748     if (p - line != 3)
 749         return -1;
 750     ms = atoi(line);
 751     if (*p != ',')
 752         return -1;
 753     line = p + 1;
 754     while (isspace(*line))
 755         ++line;
 756     if (strncmp("filepos:", line, 8))
 757         return -1;
 758     line += 8;
 759     while (isspace(*line))
 760         ++line;
 761     if (! isxdigit(*line))
 762         return -1;
 763     filepos = strtol(line, NULL, 16);
 764     return vobsub_add_timestamp(vob, filepos, vob->delay + ms + 1000 * (s + 60 * (m + 60 * h)));
 765 }
 766
 767 static int
 768 vobsub_parse_size(vobsub_t *vob, const char *line)
 769 {
 770     // size: WWWxHHH
 771     char *p;
 772     while (isspace(*line))
 773         ++line;
 774     if (!isdigit(*line))
 775         return -1;
 776     vob->orig_frame_width = strtoul(line, &p, 10);
 777     if (*p != 'x')
 778         return -1;
 779     ++p;
 780     vob->orig_frame_height = strtoul(p, NULL, 10);
 781     return 0;
 782 }
 783
 784 static int
 785 vobsub_parse_origin(vobsub_t *vob, const char *line)
 786 {
 787     // org: X,Y
 788     char *p;
 789     while (isspace(*line))
 790         ++line;
 791     if (!isdigit(*line))
 792         return -1;
 793     vob->origin_x = strtoul(line, &p, 10);
 794     if (*p != ',')
 795         return -1;
 796     ++p;
 797     vob->origin_y = strtoul(p, NULL, 10);
 798     return 0;
 799 }
 800
 801 static int
 802 vobsub_parse_palette(vobsub_t *vob, const char *line)
 803 {
 804     // palette: XXXXXX, XXXXXX, XXXXXX, XXXXXX, XXXXXX, XXXXXX, XXXXXX, XXXXXX, XXXXXX, XXXXXX, XXXXXX, XXXXXX, XXXXXX, XXXXXX, XXXXXX, XXXXXX
 805     unsigned int n;
 806     n = 0;
 807     while (1) {
 808         const char *p;
 809         int r, g, b, y, u, v, tmp;
 810         while (isspace(*line))
 811             ++line;
 812         p = line;
 813         while (isxdigit(*p))
 814             ++p;
 815         if (p - line != 6)
 816             return -1;
 817         tmp = strtoul(line, NULL, 16);
 818         r = tmp >> 16 & 0xff;
 819         g = tmp >> 8 & 0xff;
 820         b = tmp & 0xff;
 821         y = av_clip_uint8( 0.1494  * r + 0.6061 * g + 0.2445 * b);
 822         u = av_clip_uint8( 0.6066  * r - 0.4322 * g - 0.1744 * b + 128);
 823         v = av_clip_uint8(-0.08435 * r - 0.3422 * g + 0.4266 * b + 128);
 824         vob->palette[n++] = y << 16 | u << 8 | v;
 825         if (n == 16)
 826             break;
 827         if (*p == ',')
 828             ++p;
 829         line = p;
 830     }
 831     vob->have_palette = 1;
 832     return 0;
 833 }
 834
 835 static int
 836 vobsub_parse_custom(vobsub_t *vob, const char *line)
 837 {
 838     //custom colors: OFF/ON(0/1)
 839     if ((strncmp("ON", line + 15, 2) == 0)||strncmp("1", line + 15, 1) == 0)
 840         vob->custom=1;
 841     else if ((strncmp("OFF", line + 15, 3) == 0)||strncmp("0", line + 15, 1) == 0)
 842         vob->custom=0;
 843     else
 844         return -1;
 845     return 0;
 846 }
 847
 848 static int
 849 vobsub_parse_cuspal(vobsub_t *vob, const char *line)
 850 {
 851     //colors: XXXXXX, XXXXXX, XXXXXX, XXXXXX
 852     unsigned int n;
 853     n = 0;
 854     line += 40;
 855     while(1){
 856         const char *p;
 857         while (isspace(*line))
 858             ++line;
 859         p=line;
 860         while (isxdigit(*p))
 861             ++p;
 862         if (p - line !=6)
 863             return -1;
 864         vob->cuspal[n++] = strtoul(line, NULL,16);
 865         if (n==4)
 866             break;
 867         if(*p == ',')
 868             ++p;
 869         line = p;
 870     }
 871     return 0;
 872 }
 873
 874 /* don't know how to use tridx */
 875 static int
 876 vobsub_parse_tridx(const char *line)
 877 {
 878     //tridx: XXXX
 879     int tridx;
 880     tridx = strtoul((line + 26), NULL, 16);
 881     tridx = ((tridx&0x1000)>>12) | ((tridx&0x100)>>7) | ((tridx&0x10)>>2) | ((tridx&1)<<3);
 882     return tridx;
 883 }
 884
 885 static int
 886 vobsub_parse_delay(vobsub_t *vob, const char *line)
 887 {
 888     int h, m, s, ms;
 889     int forward = 1;
 890     if (*(line + 7) == '+'){
 891         forward = 1;
 892         line++;
 893     }
 894     else if (*(line + 7) == '-'){
 895         forward = -1;
 896         line++;
 897     }
 898     mp_msg(MSGT_SPUDEC,MSGL_V, "forward=%d", forward);
 899     h = atoi(line + 7);
 900     mp_msg(MSGT_VOBSUB,MSGL_V, "h=%d," ,h);
 901     m = atoi(line + 10);
 902     mp_msg(MSGT_VOBSUB,MSGL_V, "m=%d,", m);
 903     s = atoi(line + 13);
 904     mp_msg(MSGT_VOBSUB,MSGL_V, "s=%d,", s);
 905     ms = atoi(line + 16);
 906     mp_msg(MSGT_VOBSUB,MSGL_V, "ms=%d", ms);
 907     vob->delay = (ms + 1000 * (s + 60 * (m + 60 * h))) * forward;
 908     return 0;
 909 }
 910
 911 static int
 912 vobsub_set_lang(const char *line)
 913 {
 914     if (vobsub_id == -1)
 915         vobsub_id = atoi(line + 8);
 916     return 0;
 917 }
 918
 919 static int
 920 vobsub_parse_forced_subs(vobsub_t *vob, const char *line)
 921 {
 922     const char *p;
 923
 924     p  = line;
 925     while (isspace(*p))
 926         ++p;
 927
 928     if (strncasecmp("on",p,2) == 0){
 929             vob->forced_subs=~0;
 930             return 0;
 931     } else if (strncasecmp("off",p,3) == 0){
 932             vob->forced_subs=0;
 933             return 0;
 934     }
 935
 936     return -1;
 937 }
 938
 939 static int
 940 vobsub_parse_one_line(vobsub_t *vob, rar_stream_t *fd)
 941 {
 942     ssize_t line_size;
 943     int res = -1;
 944         size_t line_reserve = 0;
 945         char *line = NULL;
 946     do {
 947         line_size = vobsub_getline(&line, &line_reserve, fd);
 948         if (line_size < 0) {
 949             break;
 950         }
 951         if (*line == 0 || *line == '\r' || *line == '\n' || *line == '#')
 952             continue;
 953         else if (strncmp("langidx:", line, 8) == 0)
 954             res = vobsub_set_lang(line);
 955         else if (strncmp("delay:", line, 6) == 0)
 956             res = vobsub_parse_delay(vob, line);
 957         else if (strncmp("id:", line, 3) == 0)
 958             res = vobsub_parse_id(vob, line + 3);
 959         else if (strncmp("palette:", line, 8) == 0)
 960             res = vobsub_parse_palette(vob, line + 8);
 961         else if (strncmp("size:", line, 5) == 0)
 962             res = vobsub_parse_size(vob, line + 5);
 963         else if (strncmp("org:", line, 4) == 0)
 964             res = vobsub_parse_origin(vob, line + 4);
 965         else if (strncmp("timestamp:", line, 10) == 0)
 966             res = vobsub_parse_timestamp(vob, line + 10);
 967         else if (strncmp("custom colors:", line, 14) == 0)
 968             //custom colors: ON/OFF, tridx: XXXX, colors: XXXXXX, XXXXXX, XXXXXX,XXXXXX
 969             res = vobsub_parse_cuspal(vob, line) + vobsub_parse_tridx(line) + vobsub_parse_custom(vob, line);
 970         else if (strncmp("forced subs:", line, 12) == 0)
 971                 res = vobsub_parse_forced_subs(vob, line + 12);
 972         else {
 973             mp_msg(MSGT_VOBSUB,MSGL_V, "vobsub: ignoring %s", line);
 974             continue;
 975         }
 976         if (res < 0)
 977             mp_msg(MSGT_VOBSUB,MSGL_ERR,  "ERROR in %s", line);
 978         break;
 979     } while (1);
 980     if (line)
 981       free(line);
 982     return res;
 983 }
 984
 985 int
 986 vobsub_parse_ifo(void* this, const char *const name, unsigned int *palette, unsigned int *width, unsigned int *height, int force,
 987                  int sid, char *langid)
 988 {
 989     vobsub_t *vob = (vobsub_t*)this;
 990     int res = -1;
 991     rar_stream_t *fd = rar_open(name, "rb");
 992     if (fd == NULL) {
 993         if (force)
 994             mp_msg(MSGT_VOBSUB,MSGL_ERR, "VobSub: Can't open IFO file\n");
 995     } else {
 996         // parse IFO header
 997         unsigned char block[0x800];
 998         const char *const ifo_magic = "DVDVIDEO-VTS";
 999         if (rar_read(block, sizeof(block), 1, fd) != 1) {
1000             if (force)
1001                 mp_msg(MSGT_VOBSUB,MSGL_ERR, "VobSub: Can't read IFO header\n");
1002         } else if (memcmp(block, ifo_magic, strlen(ifo_magic) + 1))
1003             mp_msg(MSGT_VOBSUB,MSGL_ERR, "VobSub: Bad magic in IFO header\n");
1004         else {
1005             unsigned long pgci_sector = block[0xcc] << 24 | block[0xcd] << 16
1006                 | block[0xce] << 8 | block[0xcf];
1007             int standard = (block[0x200] & 0x30) >> 4;
1008             int resolution = (block[0x201] & 0x0c) >> 2;
1009             *height = standard ? 576 : 480;
1010             *width = 0;
1011             switch (resolution) {
1012             case 0x0:
1013                 *width = 720;
1014                 break;
1015             case 0x1:
1016                 *width = 704;
1017                 break;
1018             case 0x2:
1019                 *width = 352;
1020                 break;
1021             case 0x3:
1022                 *width = 352;
1023                 *height /= 2;
1024                 break;
1025             default:
1026                 mp_msg(MSGT_VOBSUB,MSGL_WARN,"Vobsub: Unknown resolution %d \n", resolution);
1027             }
1028             if (langid && 0 <= sid && sid < 32) {
1029                 unsigned char *tmp = block + 0x256 + sid * 6 + 2;
1030                 langid[0] = tmp[0];
1031                 langid[1] = tmp[1];
1032                 langid[2] = 0;
1033             }
1034             if (rar_seek(fd, pgci_sector * sizeof(block), SEEK_SET)
1035                 || rar_read(block, sizeof(block), 1, fd) != 1)
1036                 mp_msg(MSGT_VOBSUB,MSGL_ERR, "VobSub: Can't read IFO PGCI\n");
1037             else {
1038                 unsigned long idx;
1039                 unsigned long pgc_offset = block[0xc] << 24 | block[0xd] << 16
1040                     | block[0xe] << 8 | block[0xf];
1041                 for (idx = 0; idx < 16; ++idx) {
1042                     unsigned char *p = block + pgc_offset + 0xa4 + 4 * idx;
1043                     palette[idx] = p[0] << 24 | p[1] << 16 | p[2] << 8 | p[3];
1044                 }
1045                 if(vob)
1046                   vob->have_palette = 1;
1047                 res = 0;
1048             }
1049         }
1050         rar_close(fd);
1051     }
1052     return res;
1053 }
1054
1055 void *
1056 vobsub_open(const char *const name,const char *const ifo,const int force,void** spu)
1057 {
1058     vobsub_t *vob = malloc(sizeof(vobsub_t));
1059     if(spu)
1060       *spu = NULL;
1061     if (vob) {
1062         char *buf;
1063         vob->custom = 0;
1064         vob->have_palette = 0;
1065         vob->orig_frame_width = 0;
1066         vob->orig_frame_height = 0;
1067         vob->spu_streams = NULL;
1068         vob->spu_streams_size = 0;
1069         vob->spu_streams_current = 0;
1070         vob->delay = 0;
1071         vob->forced_subs=0;
1072         buf = malloc(strlen(name) + 5);
1073         if (buf) {
1074             rar_stream_t *fd;
1075             mpeg_t *mpg;
1076             /* read in the info file */
1077             if(!ifo) {
1078               strcpy(buf, name);
1079               strcat(buf, ".ifo");
1080               vobsub_parse_ifo(vob,buf, vob->palette, &vob->orig_frame_width, &vob->orig_frame_height, force, -1, NULL);
1081             } else
1082               vobsub_parse_ifo(vob,ifo, vob->palette, &vob->orig_frame_width, &vob->orig_frame_height, force, -1, NULL);
1083             /* read in the index */
1084             strcpy(buf, name);
1085             strcat(buf, ".idx");
1086             fd = rar_open(buf, "rb");
1087             if (fd == NULL) {
1088                 if(force)
1089                   mp_msg(MSGT_VOBSUB,MSGL_ERR,"VobSub: Can't open IDX file\n");
1090                 else {
1091                   free(buf);
1092                   free(vob);
1093                   return NULL;
1094                 }
1095             } else {
1096                 while (vobsub_parse_one_line(vob, fd) >= 0)
1097                     /* NOOP */ ;
1098                 rar_close(fd);
1099             }
1100             /* if no palette in .idx then use custom colors */
1101             if ((vob->custom == 0)&&(vob->have_palette!=1))
1102                 vob->custom = 1;
1103             if (spu && vob->orig_frame_width && vob->orig_frame_height)
1104               *spu = spudec_new_scaled_vobsub(vob->palette, vob->cuspal, vob->custom, vob->orig_frame_width, vob->orig_frame_height);
1105
1106             /* read the indexed mpeg_stream */
1107             strcpy(buf, name);
1108             strcat(buf, ".sub");
1109             mpg = mpeg_open(buf);
1110             if (mpg == NULL) {
1111               if(force)
1112                 mp_msg(MSGT_VOBSUB,MSGL_ERR,"VobSub: Can't open SUB file\n");
1113               else {
1114
1115                 free(buf);
1116                 free(vob);
1117                 return NULL;
1118               }
1119             } else {
1120                 long last_pts_diff = 0;
1121                 while (!mpeg_eof(mpg)) {
1122                     off_t pos = mpeg_tell(mpg);
1123                     if (mpeg_run(mpg) < 0) {
1124                         if (!mpeg_eof(mpg))
1125                             mp_msg(MSGT_VOBSUB,MSGL_ERR,"VobSub: mpeg_run error\n");
1126                         break;
1127                     }
1128                     if (mpg->packet_size) {
1129                         if ((mpg->aid & 0xe0) == 0x20) {
1130                             unsigned int sid = mpg->aid & 0x1f;
1131                             if (vobsub_ensure_spu_stream(vob, sid) >= 0)  {
1132                                 packet_queue_t *queue = vob->spu_streams + sid;
1133                                 /* get the packet to fill */
1134                                 if (queue->packets_size == 0 && packet_queue_grow(queue)  < 0)
1135                                   abort();
1136                                 while (queue->current_index + 1 < queue->packets_size
1137                                        && queue->packets[queue->current_index + 1].filepos <= pos)
1138                                     ++queue->current_index;
1139                                 if (queue->current_index < queue->packets_size) {
1140                                     packet_t *pkt;
1141                                     if (queue->packets[queue->current_index].data) {
1142                                         /* insert a new packet and fix the PTS ! */
1143                                         packet_queue_insert(queue);
1144                                         queue->packets[queue->current_index].pts100 =
1145                                             mpg->pts + last_pts_diff;
1146                                     }
1147                                     pkt = queue->packets + queue->current_index;
1148                                     if (pkt->pts100 != UINT_MAX) {
1149                                     if (queue->packets_size > 1)
1150                                         last_pts_diff = pkt->pts100 - mpg->pts;
1151                                     else
1152                                         pkt->pts100 = mpg->pts;
1153                                     /* FIXME: should not use mpg_sub internal informations, make a copy */
1154                                     pkt->data = mpg->packet;
1155                                     pkt->size = mpg->packet_size;
1156                                     mpg->packet = NULL;
1157                                     mpg->packet_reserve = 0;
1158                                     mpg->packet_size = 0;
1159                                     }
1160                                 }
1161                             }
1162                             else
1163                                 mp_msg(MSGT_VOBSUB,MSGL_WARN, "don't know what to do with subtitle #%u\n", sid);
1164                         }
1165                     }
1166                 }
1167                 vob->spu_streams_current = vob->spu_streams_size;
1168                 while (vob->spu_streams_current-- > 0)
1169                     vob->spu_streams[vob->spu_streams_current].current_index = 0;
1170                 mpeg_free(mpg);
1171             }
1172             free(buf);
1173         }
1174     }
1175     return vob;
1176 }
1177
1178 void
1179 vobsub_close(void *this)
1180 {
1181     vobsub_t *vob = (vobsub_t *)this;
1182     if (vob->spu_streams) {
1183         while (vob->spu_streams_size--)
1184             packet_queue_destroy(vob->spu_streams + vob->spu_streams_size);
1185         free(vob->spu_streams);
1186     }
1187     free(vob);
1188 }
1189
1190 unsigned int
1191 vobsub_get_indexes_count(void *vobhandle)
1192 {
1193     vobsub_t *vob = (vobsub_t *) vobhandle;
1194     return vob->spu_streams_size;
1195 }
1196
1197 char *
1198 vobsub_get_id(void *vobhandle, unsigned int index)
1199 {
1200     vobsub_t *vob = (vobsub_t *) vobhandle;
1201     return (index < vob->spu_streams_size) ? vob->spu_streams[index].id : NULL;
1202 }
1203
1204 unsigned int
1205 vobsub_get_forced_subs_flag(void const * const vobhandle)
1206 {
1207   if (vobhandle)
1208     return ((vobsub_t*) vobhandle)->forced_subs;
1209   else
1210     return 0;
1211 }
1212
1213 int
1214 vobsub_set_from_lang(void *vobhandle, unsigned char * lang)
1215 {
1216     int i;
1217     vobsub_t *vob= (vobsub_t *) vobhandle;
1218     while(lang && strlen(lang) >= 2){
1219       for(i=0; i < vob->spu_streams_size; i++)
1220         if (vob->spu_streams[i].id)
1221           if ((strncmp(vob->spu_streams[i].id, lang, 2)==0)){
1222             vobsub_id=i;
1223             mp_msg(MSGT_VOBSUB, MSGL_INFO, "Selected VOBSUB language: %d language: %s\n", i, vob->spu_streams[i].id);
1224             return 0;
1225           }
1226       lang+=2;while (lang[0]==',' || lang[0]==' ') ++lang;
1227     }
1228     mp_msg(MSGT_VOBSUB, MSGL_WARN, "No matching VOBSUB language found!\n");
1229     return -1;
1230 }
1231
1232 int
1233 vobsub_get_packet(void *vobhandle, float pts,void** data, int* timestamp) {
1234   vobsub_t *vob = (vobsub_t *)vobhandle;
1235   unsigned int pts100 = 90000 * pts;
1236   if (vob->spu_streams && 0 <= vobsub_id && (unsigned) vobsub_id < vob->spu_streams_size) {
1237     packet_queue_t *queue = vob->spu_streams + vobsub_id;
1238     while (queue->current_index < queue->packets_size) {
1239       packet_t *pkt = queue->packets + queue->current_index;
1240       if (pkt->pts100 != UINT_MAX)
1241       if (pkt->pts100 <= pts100) {
1242         ++queue->current_index;
1243         *data = pkt->data;
1244         *timestamp = pkt->pts100;
1245         return pkt->size;
1246       } else break;
1247       else
1248           ++queue->current_index;
1249     }
1250   }
1251   return -1;
1252 }
1253
1254 int
1255 vobsub_get_next_packet(void *vobhandle, void** data, int* timestamp)
1256 {
1257   vobsub_t *vob = (vobsub_t *)vobhandle;
1258   if (vob->spu_streams && 0 <= vobsub_id && (unsigned) vobsub_id < vob->spu_streams_size) {
1259     packet_queue_t *queue = vob->spu_streams + vobsub_id;
1260     if (queue->current_index < queue->packets_size) {
1261       packet_t *pkt = queue->packets + queue->current_index;
1262       ++queue->current_index;
1263       *data = pkt->data;
1264       *timestamp = pkt->pts100;
1265       return pkt->size;
1266     }
1267   }
1268   return -1;
1269 }
1270
1271 void vobsub_seek(void * vobhandle, float pts)
1272 {
1273   vobsub_t * vob = (vobsub_t *)vobhandle;
1274   packet_queue_t * queue;
1275   int seek_pts100 = (int)pts * 90000;
1276
1277   if (vob->spu_streams && 0 <= vobsub_id && (unsigned) vobsub_id < vob->spu_streams_size) {
1278     /* do not seek if we don't know the id */
1279     if (vobsub_get_id(vob, vobsub_id) == NULL)
1280             return;
1281     queue = vob->spu_streams + vobsub_id;
1282     queue->current_index = 0;
1283     while ((queue->packets + queue->current_index)->pts100 < seek_pts100)
1284       ++queue->current_index;
1285     if (queue->current_index > 0)
1286       --queue->current_index;
1287   }
1288 }
1289
1290 void
1291 vobsub_reset(void *vobhandle)
1292 {
1293     vobsub_t *vob = (vobsub_t *)vobhandle;
1294     if (vob->spu_streams) {
1295         unsigned int n = vob->spu_streams_size;
1296         while (n-- > 0)
1297             vob->spu_streams[n].current_index = 0;
1298     }
1299 }
1300
1301 /**********************************************************************
1302  * Vobsub output
1303  **********************************************************************/
1304
1305 typedef struct {
1306     FILE *fsub;
1307     FILE *fidx;
1308     unsigned int aid;
1309 } vobsub_out_t;
1310
1311 static void
1312 create_idx(vobsub_out_t *me, const unsigned int *palette, unsigned int orig_width, unsigned int orig_height)
1313 {
1314     int i;
1315     fprintf(me->fidx,
1316             "# VobSub index file, v7 (do not modify this line!)\n"
1317             "#\n"
1318             "# Generated by MPlayer " VERSION "\n"
1319             "# See <URL:http://www.mplayerhq.hu/> for more information about MPlayer\n"
1320             "# See <URL:http://vobsub.edensrising.com/> for more information about Vobsub\n"
1321             "#\n"
1322             "size: %ux%u\n",
1323             orig_width, orig_height);
1324     if (palette) {
1325         fputs("palette:", me->fidx);
1326         for (i = 0; i < 16; ++i) {
1327             const double y = palette[i] >> 16 & 0xff,
1328                 u = (palette[i] >> 8 & 0xff) - 128.0,
1329                 v = (palette[i] & 0xff) - 128.0;
1330             if (i)
1331                 putc(',', me->fidx);
1332             fprintf(me->fidx, " %02x%02x%02x",
1333                     av_clip_uint8(y + 1.4022 * u),
1334                     av_clip_uint8(y - 0.3456 * u - 0.7145 * v),
1335                     av_clip_uint8(y + 1.7710 * v));
1336         }
1337         putc('\n', me->fidx);
1338     }
1339
1340     fprintf(me->fidx,"# ON: displays only forced subtitles, OFF: shows everything\n"
1341             "forced subs: OFF\n");
1342 }
1343
1344 void *
1345 vobsub_out_open(const char *basename, const unsigned int *palette,
1346                 unsigned int orig_width, unsigned int orig_height,
1347                 const char *id, unsigned int index)
1348 {
1349     vobsub_out_t *result = NULL;
1350     char *filename;
1351     filename = malloc(strlen(basename) + 5);
1352     if (filename) {
1353         result = malloc(sizeof(vobsub_out_t));
1354         if (result) {
1355             result->aid = index;
1356             strcpy(filename, basename);
1357             strcat(filename, ".sub");
1358             result->fsub = fopen(filename, "ab");
1359             if (result->fsub == NULL)
1360                 perror("Error: vobsub_out_open subtitle file open failed");
1361             strcpy(filename, basename);
1362             strcat(filename, ".idx");
1363             result->fidx = fopen(filename, "ab");
1364             if (result->fidx) {
1365                 if (ftell(result->fidx) == 0){
1366                     create_idx(result, palette, orig_width, orig_height);
1367                     /* Make the selected language the default language */
1368                     fprintf(result->fidx, "\n# Language index in use\nlangidx: %u\n", index);
1369                 }
1370                 fprintf(result->fidx, "\nid: %s, index: %u\n", id ? id : "xx", index);
1371                 /* So that we can check the file now */
1372                 fflush(result->fidx);
1373             }
1374             else
1375                 perror("Error: vobsub_out_open index file open failed");
1376             free(filename);
1377         }
1378     }
1379     return result;
1380 }
1381
1382 void
1383 vobsub_out_close(void *me)
1384 {
1385     vobsub_out_t *vob = (vobsub_out_t*)me;
1386     if (vob->fidx)
1387         fclose(vob->fidx);
1388     if (vob->fsub)
1389         fclose(vob->fsub);
1390     free(vob);
1391 }
1392
1393 void
1394 vobsub_out_output(void *me, const unsigned char *packet, int len, double pts)
1395 {
1396     static double last_pts;
1397     static int last_pts_set = 0;
1398     vobsub_out_t *vob = (vobsub_out_t*)me;
1399     if (vob->fsub) {
1400         /*  Windows' Vobsub require that every packet is exactly 2kB long */
1401         unsigned char buffer[2048];
1402         unsigned char *p;
1403         int remain = 2048;
1404         /* Do not output twice a line with the same timestamp, this
1405            breaks Windows' Vobsub */
1406         if (vob->fidx && (!last_pts_set || last_pts != pts)) {
1407             static unsigned int last_h = 9999, last_m = 9999, last_s = 9999, last_ms = 9999;
1408             unsigned int h, m, ms;
1409             double s;
1410             s = pts;
1411             h = s / 3600;
1412             s -= h * 3600;
1413             m = s / 60;
1414             s -= m * 60;
1415             ms = (s - (unsigned int) s) * 1000;
1416             if (ms >= 1000)     /* prevent overfolws or bad float stuff */
1417                 ms = 0;
1418             if (h != last_h || m != last_m || (unsigned int) s != last_s || ms != last_ms) {
1419                 fprintf(vob->fidx, "timestamp: %02u:%02u:%02u:%03u, filepos: %09lx\n",
1420                         h, m, (unsigned int) s, ms, ftell(vob->fsub));
1421                 last_h = h;
1422                 last_m = m;
1423                 last_s = (unsigned int) s;
1424                 last_ms = ms;
1425             }
1426         }
1427         last_pts = pts;
1428         last_pts_set = 1;
1429
1430         /* Packet start code: Windows' Vobsub needs this */
1431         p = buffer;
1432         *p++ = 0;               /* 0x00 */
1433         *p++ = 0;
1434         *p++ = 1;
1435         *p++ = 0xba;
1436         *p++ = 0x40;
1437         memset(p, 0, 9);
1438         p += 9;
1439         {   /* Packet */
1440             static unsigned char last_pts[5] = { 0, 0, 0, 0, 0};
1441             unsigned char now_pts[5];
1442             int pts_len, pad_len, datalen = len;
1443             pts *= 90000;
1444             now_pts[0] = 0x21 | (((unsigned long)pts >> 29) & 0x0e);
1445             now_pts[1] = ((unsigned long)pts >> 22) & 0xff;
1446             now_pts[2] = 0x01 | (((unsigned long)pts >> 14) & 0xfe);
1447             now_pts[3] = ((unsigned long)pts >> 7) & 0xff;
1448             now_pts[4] = 0x01 | (((unsigned long)pts << 1) & 0xfe);
1449             pts_len = memcmp(last_pts, now_pts, sizeof(now_pts)) ? sizeof(now_pts) : 0;
1450             memcpy(last_pts, now_pts, sizeof(now_pts));
1451
1452             datalen += 3;       /* Version, PTS_flags, pts_len */
1453             datalen += pts_len;
1454             datalen += 1;       /* AID */
1455             pad_len = 2048 - (p - buffer) - 4 /* MPEG ID */ - 2 /* payload len */ - datalen;
1456             /* XXX - Go figure what should go here!  In any case the
1457                packet has to be completly filled.  If I can fill it
1458                with padding (0x000001be) latter I'll do that.  But if
1459                there is only room for 6 bytes then I can not write a
1460                padding packet.  So I add some padding in the PTS
1461                field.  This looks like a dirty kludge.  Oh well... */
1462             if (pad_len < 0) {
1463                 /* Packet is too big.  Let's try ommiting the PTS field */
1464                 datalen -= pts_len;
1465                 pts_len = 0;
1466                 pad_len = 0;
1467             }
1468             else if (pad_len > 6)
1469                 pad_len = 0;
1470             datalen += pad_len;
1471
1472             *p++ = 0;           /* 0x0e */
1473             *p++ = 0;
1474             *p++ = 1;
1475             *p++ = 0xbd;
1476
1477             *p++ = (datalen >> 8) & 0xff; /* length of payload */
1478             *p++ = datalen & 0xff;
1479             *p++ = 0x80;                /* System-2 (.VOB) stream */
1480             *p++ = pts_len ? 0x80 : 0x00; /* pts_flags */
1481             *p++ = pts_len + pad_len;
1482             memcpy(p, now_pts, pts_len);
1483             p += pts_len;
1484             memset(p, 0, pad_len);
1485             p += pad_len;
1486         }
1487         *p++ = 0x20 |  vob->aid; /* aid */
1488         if (fwrite(buffer, p - buffer, 1, vob->fsub) != 1
1489             || fwrite(packet, len, 1, vob->fsub) != 1)
1490             perror("ERROR: vobsub write failed");
1491         else
1492             remain -= p - buffer + len;
1493
1494         /* Padding */
1495         if (remain >= 6) {
1496             p = buffer;
1497             *p++ = 0x00;
1498             *p++ = 0x00;
1499             *p++ = 0x01;
1500             *p++ = 0xbe;
1501             *p++ = (remain - 6) >> 8;
1502             *p++ = (remain - 6) & 0xff;
1503             /* for better compression, blank this */
1504             memset(buffer + 6, 0, remain - (p - buffer));
1505             if (fwrite(buffer, remain, 1, vob->fsub) != 1)
1506                 perror("ERROR: vobsub padding write failed");
1507         }
1508         else if (remain > 0) {
1509             /* I don't know what to output.  But anyway the block
1510                needs to be 2KB big */
1511             memset(buffer, 0, remain);
1512             if (fwrite(buffer, remain, 1, vob->fsub) != 1)
1513                 perror("ERROR: vobsub blank padding write failed");
1514         }
1515         else if (remain < 0)
1516             fprintf(stderr,
1517                     "\nERROR: wrong thing happenned...\n"
1518                     "  I wrote a %i data bytes spu packet and that's too long\n", len);
1519     }
1520 }