src/bin/translate.cpp

   1 /*
   2  * Copyright 2003-2007, Haiku. All Rights Reserved.
   3  * Distributed under the terms of the MIT license.
   4  *
   5  * Authors:
   6  *              Axel Dörfler, axeld@pinc-software.de
   7  *              jonas.sundstrom@kirilla.com
   8  */
   9
  10
  11 #include <TranslationKit.h>
  12 #include <Application.h>
  13 #include <String.h>
  14 #include <File.h>
  15 #include <Path.h>
  16 #include <Entry.h>
  17 #include <Mime.h>
  18 #include <NodeInfo.h>
  19
  20 #include <ctype.h>
  21 #include <stdio.h>
  22 #include <stdlib.h>
  23 #include <strings.h>
  24
  25
  26 extern const char *__progname;
  27 const char *gProgramName = __progname;
  28 bool gVerbose = false;
  29
  30
  31 class TypeList {
  32         public:
  33                 void Add(uint32 type);
  34                 bool Remove(uint32 type);
  35                 bool FindType(uint32 type);
  36
  37                 void SetTo(TypeList &types);
  38                 int32 Count();
  39                 uint32 TypeAt(int32 index);
  40
  41         private:
  42                 BList   fList;
  43 };
  44
  45 class RemovingFile : public BFile {
  46         public:
  47                 RemovingFile(const char *path);
  48                 ~RemovingFile();
  49
  50                 void Keep();
  51
  52         private:
  53                 BEntry  fEntry;
  54 };
  55
  56 class Translator {
  57         public:
  58                 Translator(const char *inPath, const char *outPath, uint32 outFormat);
  59                 ~Translator();
  60
  61                 status_t Translate();
  62
  63         private:
  64                 status_t Directly(BFile &input, translator_info &info, BFile &output);
  65                 status_t Indirectly(BFile &input, BFile &output);
  66                 status_t FindPath(const translation_format *info, BPositionIO &stream,
  67                                         TypeList &typesSeen, TypeList &path, double &pathQuality);
  68                 status_t GetMimeTypeFromCode(uint32 type, char *mimeType);
  69
  70         private:
  71                 BTranslatorRoster *fRoster;
  72                 BPath   fInputPath, fOutputPath;
  73                 uint32  fOutputFormat;
  74 };
  75
  76 class TranslateApp : public BApplication {
  77         public:
  78                 TranslateApp(void);
  79                 virtual ~TranslateApp();
  80
  81                 virtual void ReadyToRun(void);
  82                 virtual void ArgvReceived(int32 argc, char **argv);
  83
  84         private:
  85                 void PrintUsage(void);
  86                 void ListTranslators(uint32 type);
  87
  88                 uint32 GetTypeCodeForOutputMime(const char *mime);
  89                 uint32 GetTypeCodeFromString(const char *string);
  90                 status_t Translate(BFile &input, translator_info &translator, BFile &output, uint32 type);
  91                 status_t Translate(BFile &input, BFile &output, uint32 type);
  92                 status_t Translate(const char *inPath, const char *outPath, uint32 type);
  93
  94                 bool                            fGotArguments;
  95                 BTranslatorRoster       *fTranslatorRoster;
  96                 int32                           fTranslatorCount;
  97                 translator_id           *fTranslatorArray;
  98 };
  99
 100
 101 static void
 102 print_tupel(const char *format, uint32 value)
 103 {
 104         char tupel[5];
 105
 106         for (int32 i = 0; i < 4; i++) {
 107                 tupel[i] = (value >> (24 - i * 8)) & 0xff;
 108                 if (!isprint(tupel[i]))
 109                         tupel[i] = '.';
 110         }
 111         tupel[4] = '\0';
 112
 113         printf(format, tupel);
 114 }
 115
 116
 117 static void
 118 print_translation_format(const translation_format &format)
 119 {
 120         print_tupel("'%s' ", format.type);
 121         print_tupel("(%s) ", format.group);
 122
 123         printf("%.1f %.1f %s ; %s\n", format.quality, format.capability,
 124                 format.MIME, format.name);
 125 }
 126
 127
 128 //      #pragma mark -
 129
 130
 131 void
 132 TypeList::Add(uint32 type)
 133 {
 134         fList.AddItem((void *)(addr_t)type, 0);
 135 }
 136
 137
 138 bool
 139 TypeList::Remove(uint32 type)
 140 {
 141         return fList.RemoveItem((void *)(addr_t)type);
 142 }
 143
 144
 145 bool
 146 TypeList::FindType(uint32 type)
 147 {
 148         return fList.IndexOf((void *)(addr_t)type) >= 0;
 149 }
 150
 151
 152 void
 153 TypeList::SetTo(TypeList &types)
 154 {
 155         fList.MakeEmpty();
 156
 157         for (int32 i = 0; i < types.Count(); i++)
 158                 fList.AddItem((void *)(addr_t)types.TypeAt(i));
 159 }
 160
 161
 162 int32
 163 TypeList::Count()
 164 {
 165         return fList.CountItems();
 166 }
 167
 168
 169 uint32
 170 TypeList::TypeAt(int32 index)
 171 {
 172         return (uint32)(addr_t)fList.ItemAt(index);
 173 }
 174
 175
 176 //      #pragma mark -
 177
 178
 179 RemovingFile::RemovingFile(const char *path)
 180         : BFile(path, B_READ_WRITE | B_CREATE_FILE | B_ERASE_FILE),
 181         fEntry(path)
 182 {
 183 }
 184
 185
 186 RemovingFile::~RemovingFile()
 187 {
 188         fEntry.Remove();
 189 }
 190
 191
 192 void
 193 RemovingFile::Keep()
 194 {
 195         fEntry.Unset();
 196 }
 197
 198
 199 //      #pragma mark -
 200
 201
 202 Translator::Translator(const char *inPath, const char *outPath, uint32 outputFormat)
 203         :
 204         fRoster(BTranslatorRoster::Default()),
 205         fInputPath(inPath),
 206         fOutputPath(outPath),
 207         fOutputFormat(outputFormat)
 208 {
 209 }
 210
 211
 212 Translator::~Translator()
 213 {
 214 }
 215
 216
 217 status_t
 218 Translator::Translate()
 219 {
 220         // input file
 221         BFile input;
 222         status_t status = input.SetTo(fInputPath.Path(), B_READ_ONLY);
 223         if (status != B_OK) {
 224                 fprintf(stderr, "%s: could not open \"%s\": %s\n",
 225                         gProgramName, fInputPath.Path(), strerror(status));
 226                 return status;
 227         }
 228
 229         // find a direct translator
 230         bool direct = true;
 231         translator_info translator;
 232         status = fRoster->Identify(&input, NULL, &translator, 0, NULL, fOutputFormat);
 233         if (status < B_OK) {
 234                 // no direct translator found - let's try with something else
 235                 status = fRoster->Identify(&input, NULL, &translator);
 236                 if (status < B_OK) {
 237                         fprintf(stderr, "%s: identifying \"%s\" failed: %s\n",
 238                                 gProgramName, fInputPath.Path(), strerror(status));
 239                         return status;
 240                 }
 241
 242                 direct = false;
 243         }
 244
 245         // output file
 246         RemovingFile output(fOutputPath.Path());
 247         if ((status = output.InitCheck()) != B_OK) {
 248                 fprintf(stderr, "%s: Could not create \"%s\": %s\n",
 249                         gProgramName, fOutputPath.Path(), strerror(status));
 250                 return status;
 251         }
 252
 253         if (direct)
 254                 status = Directly(input, translator, output);
 255         else
 256                 status = Indirectly(input, output);
 257
 258         if (status == B_OK) {
 259                 output.Keep();
 260
 261                 // add filetype attribute
 262                 update_mime_info(fOutputPath.Path(), false, true, false);
 263
 264                 char mimeType[B_ATTR_NAME_LENGTH];
 265                 BNode node(fOutputPath.Path());
 266                 BNodeInfo info(&node);
 267                 if (info.GetType(mimeType) != B_OK || !strcasecmp(mimeType, B_FILE_MIME_TYPE)) {
 268                         // the Registrar couldn't find a type for this file
 269                         // so let's use the information we have from the
 270                         // translator
 271                         if (GetMimeTypeFromCode(fOutputFormat, mimeType) == B_OK)
 272                                 info.SetType(mimeType);
 273                 }
 274         } else {
 275                 fprintf(stderr, "%s: translating failed: %s\n",
 276                         gProgramName, strerror(status));
 277         }
 278
 279         return status;
 280 }
 281
 282
 283 /** Converts the input file to the output file using the
 284  *      specified translator.
 285  */
 286
 287 status_t
 288 Translator::Directly(BFile &input, translator_info &info, BFile &output)
 289 {
 290         if (gVerbose)
 291                 printf("Direct translation from \"%s\"\n", info.name);
 292
 293         return fRoster->Translate(&input, &info, NULL, &output, fOutputFormat);
 294 }
 295
 296
 297 /**     Converts the input file to the output file by computing the best
 298  *      quality path between the input type and the output type, and then
 299  *      applies as many translators as needed.
 300  */
 301
 302 status_t
 303 Translator::Indirectly(BFile &input, BFile &output)
 304 {
 305         TypeList translatorPath;
 306         TypeList handledTypes;
 307         double quality;
 308
 309         if (FindPath(NULL, input, handledTypes, translatorPath, quality) != B_OK)
 310                 return B_NO_TRANSLATOR;
 311
 312         // The initial input stream is the input file which gets translated into
 313         // the first buffer. After that, the two buffers fill each other, until
 314         // the end is reached and the output file is the translation target
 315
 316         BMallocIO buffer[2];
 317         BPositionIO *inputStream = &input;
 318         BPositionIO *outputStream = &buffer[0];
 319
 320         for (int32 i = 0; i < translatorPath.Count(); i++) {
 321                 uint32 type = translatorPath.TypeAt(i);
 322                 if (type == fOutputFormat)
 323                         outputStream = &output;
 324                 else
 325                         outputStream->SetSize(0);
 326
 327                 inputStream->Seek(0, SEEK_SET);
 328                         // rewind the input stream
 329
 330                 status_t status = fRoster->Translate(inputStream, NULL, NULL, outputStream, type);
 331                 if (status != B_OK)
 332                         return status;
 333
 334                 // switch buffers
 335                 inputStream = &buffer[i % 2];
 336                 outputStream = &buffer[(i + 1) % 2];
 337
 338                 if (gVerbose)
 339                         print_tupel("  '%s'\n", type);
 340         }
 341
 342         return B_OK;
 343 }
 344
 345
 346 status_t
 347 Translator::FindPath(const translation_format *format, BPositionIO &stream,
 348         TypeList &typesSeen, TypeList &path, double &pathQuality)
 349 {
 350         translator_info *infos = NULL;
 351         translator_id *ids = NULL;
 352         int32 count;
 353         uint32 inFormat = 0;
 354         uint32 group = 0;
 355         status_t status;
 356
 357         // Get a list of capable translators (or all of them)
 358
 359         if (format == NULL) {
 360                 status = fRoster->GetTranslators(&stream, NULL, &infos, &count);
 361                 if (status == B_OK && count > 0) {
 362                         inFormat = infos[0].type;
 363                         group = infos[0].group;
 364
 365                         if (gVerbose) {
 366                                 puts("Indirect translation:");
 367                                 print_tupel("  '%s', ", inFormat);
 368                                 printf("%s\n", infos[0].name);
 369                         }
 370                 }
 371         } else {
 372                 status = fRoster->GetAllTranslators(&ids, &count);
 373                 inFormat = format->type;
 374                 group = format->group;
 375         }
 376         if (status != B_OK || count == 0) {
 377                 delete[] infos;
 378                 delete[] ids;
 379                 return status;
 380         }
 381
 382         // build the best path to get from here to fOutputFormat recursively
 383         // (via depth search, best quality/capability wins)
 384
 385         TypeList bestPath;
 386         double bestQuality = -1;
 387         status = B_NO_TRANSLATOR;
 388
 389         for (int32 i = 0; i < count; i++) {
 390                 const translation_format *formats;
 391                 int32 formatCount;
 392                 bool matches = false;
 393                 int32 id = ids ? ids[i] : infos[i].translator;
 394                 if (fRoster->GetInputFormats(id, &formats, &formatCount) != B_OK)
 395                         continue;
 396
 397                 // see if this translator is good enough for us
 398                 for (int32 j = 0; j < formatCount; j++) {
 399                         if (formats[j].type == inFormat) {
 400                                 matches = true;
 401                                 break;
 402                         }
 403                 }
 404
 405                 if (!matches)
 406                         continue;
 407
 408                 // search output formats
 409
 410                 if (fRoster->GetOutputFormats(id, &formats, &formatCount) != B_OK)
 411                         continue;
 412
 413                 typesSeen.Add(inFormat);
 414
 415                 for (int32 j = 0; j < formatCount; j++) {
 416                         if (formats[j].group != group || typesSeen.FindType(formats[j].type))
 417                                 continue;
 418
 419                         double formatQuality = formats[j].quality * formats[j].capability;
 420
 421                         if (formats[j].type == fOutputFormat) {
 422                                 // we've found our target type, so we can stop the path here
 423                                 bestPath.Add(formats[j].type);
 424                                 bestQuality = formatQuality;
 425                                 status = B_OK;
 426                                 continue;
 427                         }
 428
 429                         TypeList path;
 430                         double quality;
 431                         if (FindPath(&formats[j], stream, typesSeen, path, quality) == B_OK) {
 432                                 if (bestQuality < quality * formatQuality) {
 433                                         bestQuality = quality * formatQuality;
 434                                         bestPath.SetTo(path);
 435                                         bestPath.Add(formats[j].type);
 436                                         status = B_OK;
 437                                 }
 438                         }
 439                 }
 440
 441                 typesSeen.Remove(inFormat);
 442         }
 443
 444         if (status == B_OK) {
 445                 pathQuality = bestQuality;
 446                 path.SetTo(bestPath);
 447         }
 448         delete[] infos;
 449         delete[] ids;
 450         return status;
 451 }
 452
 453
 454 status_t
 455 Translator::GetMimeTypeFromCode(uint32 type, char *mimeType)
 456 {
 457         translator_id *ids = NULL;
 458         int32 count;
 459         status_t status = fRoster->GetAllTranslators(&ids, &count);
 460         if (status != B_OK)
 461                 return status;
 462
 463         status = B_NO_TRANSLATOR;
 464
 465         for (int32 i = 0; i < count; i++) {
 466                 const translation_format *format = NULL;
 467                 int32 formatCount = 0;
 468                 fRoster->GetOutputFormats(ids[i], &format, &formatCount);
 469
 470                 for (int32 j = 0; j < formatCount; j++) {
 471                         if (type == format[j].type) {
 472                                 strcpy(mimeType, format[j].MIME);
 473                                 status = B_OK;
 474                                 break;
 475                         }
 476                 }
 477         }
 478
 479         delete[] ids;
 480         return status;
 481 }
 482
 483
 484 //      #pragma mark -
 485
 486
 487 TranslateApp::TranslateApp(void)
 488         : BApplication("application/x-vnd.haiku-translate"),
 489         fGotArguments(false),
 490         fTranslatorRoster(BTranslatorRoster::Default()),
 491         fTranslatorCount(0),
 492         fTranslatorArray(NULL)
 493 {
 494         fTranslatorRoster->GetAllTranslators(&fTranslatorArray, &fTranslatorCount);
 495 }
 496
 497
 498 TranslateApp::~TranslateApp()
 499 {
 500         delete[] fTranslatorArray;
 501 }
 502
 503
 504 void
 505 TranslateApp::ArgvReceived(int32 argc, char **argv)
 506 {
 507         if (argc < 2
 508                 || !strcmp(argv[1], "--help"))
 509                 return;
 510
 511         if (!strcmp(argv[1], "--list")) {
 512                 fGotArguments = true;
 513
 514                 uint32 type = B_TRANSLATOR_ANY_TYPE;
 515                 if (argc > 2)
 516                         type = GetTypeCodeFromString(argv[2]);
 517
 518                 ListTranslators(type);
 519                 return;
 520         }
 521
 522         if (!strcmp(argv[1], "--verbose")) {
 523                 fGotArguments = true;
 524                 argc--;
 525                 argv++;
 526                 gVerbose = true;
 527         }
 528
 529         if (argc != 4)
 530                 return;
 531
 532         fGotArguments = true;
 533
 534         // get typecode of output format
 535         uint32 outputFormat = 0;
 536         BMimeType mime(argv[3]);
 537
 538         if (mime.IsValid() && !mime.IsSupertypeOnly()) {
 539                 // MIME-string
 540                 outputFormat = GetTypeCodeForOutputMime(argv[3]);
 541         } else
 542                 outputFormat = GetTypeCodeFromString(argv[3]);
 543
 544         if (outputFormat == 0) {
 545                 fprintf(stderr, "%s: bad format: %s\nformat is 4-byte type code or full MIME type\n",
 546                         gProgramName, argv[3]);
 547                 exit(-1);
 548         }
 549
 550         Translator translator(argv[1], argv[2], outputFormat);
 551         status_t status = translator.Translate();
 552         if (status < B_OK)
 553                 exit(-1);
 554 }
 555
 556
 557 void
 558 TranslateApp::ReadyToRun(void)
 559 {
 560         if (fGotArguments == false)
 561                 PrintUsage();
 562
 563         PostMessage(B_QUIT_REQUESTED);
 564 }
 565
 566
 567 void
 568 TranslateApp::PrintUsage(void)
 569 {
 570         printf("usage: %s { --list [type] | input output format }\n"
 571                 "\t\"format\" can expressed as 4-byte type code (ie. 'TEXT') or as MIME type.\n",
 572                 gProgramName);
 573 }
 574
 575
 576 void
 577 TranslateApp::ListTranslators(uint32 type)
 578 {
 579         for (int32 i = 0; i < fTranslatorCount; i++) {
 580                 const char *name = NULL;
 581                 const char *info = NULL;
 582                 int32 version = 0;
 583                 if (fTranslatorRoster->GetTranslatorInfo(fTranslatorArray[i], &name, &info, &version) != B_OK)
 584                         continue;
 585
 586                 const translation_format *inputFormats = NULL;
 587                 const translation_format *outputFormats = NULL;
 588                 int32 inCount = 0, outCount = 0;
 589                 fTranslatorRoster->GetInputFormats(fTranslatorArray[i], &inputFormats, &inCount);
 590                 fTranslatorRoster->GetOutputFormats(fTranslatorArray[i], &outputFormats, &outCount);
 591
 592                 // test if the translator has formats of the specified type
 593
 594                 if (type != B_TRANSLATOR_ANY_TYPE) {
 595                         bool matches = false;
 596
 597                         for (int32 j = 0; j < inCount; j++) {
 598                                 if (inputFormats[j].group == type || inputFormats[j].type == type) {
 599                                         matches = true;
 600                                         break;
 601                                 }
 602                         }
 603
 604                         for (int32 j = 0; j < outCount; j++) {
 605                                 if (outputFormats[j].group == type || outputFormats[j].type == type) {
 606                                         matches = true;
 607                                         break;
 608                                 }
 609                         }
 610
 611                         if (!matches)
 612                                 continue;
 613                 }
 614
 615                 printf("name: %s\ninfo: %s\nversion: %" B_PRId32 ".%" B_PRId32 ".%"
 616                         B_PRId32 "\n", name, info,
 617                         B_TRANSLATION_MAJOR_VERSION(version),
 618                         B_TRANSLATION_MINOR_VERSION(version),
 619                         B_TRANSLATION_REVISION_VERSION(version));
 620
 621                 for (int32 j = 0; j < inCount; j++) {
 622                         printf("  input:\t");
 623                         print_translation_format(inputFormats[j]);
 624                 }
 625
 626                 for (int32 j = 0; j < outCount; j++) {
 627                         printf("  output:\t");
 628                         print_translation_format(outputFormats[j]);
 629                 }
 630
 631                 printf("\n");
 632         }
 633 }
 634
 635
 636 uint32
 637 TranslateApp::GetTypeCodeForOutputMime(const char *mime)
 638 {
 639         for (int32 i = 0; i < fTranslatorCount; i++) {
 640                 const translation_format *format = NULL;
 641                 int32 count = 0;
 642                 fTranslatorRoster->GetOutputFormats(fTranslatorArray[i], &format, &count);
 643
 644                 for (int32 j = 0; j < count; j++) {
 645                         if (!strcmp(mime, format[j].MIME))
 646                                 return format[j].type;
 647                 }
 648         }
 649
 650         return 0;
 651 }
 652
 653
 654 uint32
 655 TranslateApp::GetTypeCodeFromString(const char *string)
 656 {
 657         size_t length = strlen(string);
 658         if (length > 4)
 659                 return 0;
 660
 661         uint8 code[4] = {' ', ' ', ' ', ' '};
 662
 663         for (uint32 i = 0; i < length; i++)
 664                 code[i] = (uint8)string[i];
 665
 666         return B_HOST_TO_BENDIAN_INT32(*(uint32 *)code);
 667 }
 668
 669
 670 //      #pragma mark -
 671
 672
 673 int
 674 main()
 675 {
 676         new TranslateApp();
 677         be_app->Run();
 678
 679         return B_OK;
 680 }
 681