src/kits/media/MediaFile.cpp

   1 /*
   2  * Copyright 2009, Stephan Aßmus <superstippi@gmx.de>
   3  * Copyright 2002-2004, Marcus Overhagen <marcus@overhagen.de>
   4  * All rights reserved. Distributed under the terms of the MIT license.
   5  */
   6
   7 #include <MediaFile.h>
   8
   9 #include <new>
  10
  11 #include <stdlib.h>
  12 #include <string.h>
  13
  14 #include <File.h>
  15 #include <MediaTrack.h>
  16 #include <Url.h>
  17
  18 #include "debug.h"
  19
  20 #include "MediaExtractor.h"
  21 #include "MediaStreamer.h"
  22 #include "MediaWriter.h"
  23
  24
  25 BMediaFile::BMediaFile(const entry_ref* ref)
  26 {
  27         CALLED();
  28         _Init();
  29         fDeleteSource = true;
  30         _InitReader(new(std::nothrow) BFile(ref, O_RDONLY));
  31 }
  32
  33
  34 BMediaFile::BMediaFile(BDataIO* source)
  35 {
  36         CALLED();
  37         _Init();
  38         _InitReader(source);
  39 }
  40
  41
  42 BMediaFile::BMediaFile(const entry_ref* ref, int32 flags)
  43 {
  44         CALLED();
  45         _Init();
  46         fDeleteSource = true;
  47         _InitReader(new(std::nothrow) BFile(ref, O_RDONLY), NULL, flags);
  48 }
  49
  50
  51 BMediaFile::BMediaFile(BDataIO* source, int32 flags)
  52 {
  53         CALLED();
  54         _Init();
  55         _InitReader(source, NULL, flags);
  56 }
  57
  58
  59 BMediaFile::BMediaFile(const entry_ref* ref, const media_file_format* mfi,
  60         int32 flags)
  61 {
  62         CALLED();
  63         _Init();
  64         fDeleteSource = true;
  65         _InitWriter(new(std::nothrow) BFile(ref, B_CREATE_FILE | B_ERASE_FILE
  66                 | B_WRITE_ONLY), NULL, mfi, flags);
  67 }
  68
  69
  70 BMediaFile::BMediaFile(BDataIO* destination, const media_file_format* mfi,
  71         int32 flags)
  72 {
  73         CALLED();
  74         _Init();
  75         _InitWriter(destination, NULL, mfi, flags);
  76 }
  77
  78
  79 // File will be set later by SetTo()
  80 BMediaFile::BMediaFile(const media_file_format* mfi, int32 flags)
  81 {
  82         debugger("BMediaFile::BMediaFile not implemented");
  83 }
  84
  85
  86 BMediaFile::BMediaFile(const BUrl& url)
  87 {
  88         CALLED();
  89         _Init();
  90         fDeleteSource = true;
  91         _InitReader(NULL, &url);
  92 }
  93
  94
  95 BMediaFile::BMediaFile(const BUrl& url, int32 flags)
  96 {
  97         CALLED();
  98         _Init();
  99         fDeleteSource = true;
 100         _InitReader(NULL, &url, flags);
 101 }
 102
 103
 104 BMediaFile::BMediaFile(const BUrl& destination, const media_file_format* mfi,
 105         int32 flags)
 106 {
 107         CALLED();
 108         _Init();
 109         fDeleteSource = true;
 110         _InitWriter(NULL, &destination, mfi, flags);
 111         // TODO: Implement streaming server support, it's
 112         // a pretty complex thing compared to client mode
 113         // and will require to expand the current BMediaFile
 114         // design to be aware of it.
 115 }
 116
 117
 118 status_t
 119 BMediaFile::SetTo(const entry_ref* ref)
 120 {
 121         CALLED();
 122
 123         if (ref == NULL)
 124                 return B_BAD_VALUE;
 125
 126         _UnInit();
 127         fDeleteSource = true;
 128         _InitReader(new(std::nothrow) BFile(ref, O_RDONLY));
 129
 130         return fErr;
 131 }
 132
 133
 134 status_t
 135 BMediaFile::SetTo(BDataIO* destination)
 136 {
 137         CALLED();
 138
 139         if (destination == NULL)
 140                 return B_BAD_VALUE;
 141
 142         _UnInit();
 143         _InitReader(destination);
 144
 145         return fErr;
 146 }
 147
 148
 149 status_t
 150 BMediaFile::SetTo(const BUrl& url)
 151 {
 152         CALLED();
 153
 154         _UnInit();
 155         _InitReader(NULL, &url);
 156
 157         return fErr;
 158 }
 159
 160
 161 BMediaFile::~BMediaFile()
 162 {
 163         CALLED();
 164
 165         _UnInit();
 166 }
 167
 168
 169 status_t
 170 BMediaFile::InitCheck() const
 171 {
 172         CALLED();
 173         return fErr;
 174 }
 175
 176
 177 status_t
 178 BMediaFile::GetFileFormatInfo(media_file_format* mfi) const
 179 {
 180         CALLED();
 181         if (mfi == NULL)
 182                 return B_BAD_VALUE;
 183         if (fErr)
 184                 return B_ERROR;
 185         *mfi = fMFI;
 186         return B_OK;
 187 }
 188
 189
 190 status_t
 191 BMediaFile::GetMetaData(BMessage* _data) const
 192 {
 193         if (fExtractor == NULL)
 194                 return B_NO_INIT;
 195         if (_data == NULL)
 196                 return B_BAD_VALUE;
 197
 198         _data->MakeEmpty();
 199
 200         return fExtractor->GetMetaData(_data);
 201 }
 202
 203
 204 const char*
 205 BMediaFile::Copyright() const
 206 {
 207         return fExtractor->Copyright();
 208 }
 209
 210
 211 int32
 212 BMediaFile::CountTracks() const
 213 {
 214         return fTrackNum;
 215 }
 216
 217
 218 // Can be called multiple times with the same index.  You must call
 219 // ReleaseTrack() when you're done with a track.
 220 BMediaTrack*
 221 BMediaFile::TrackAt(int32 index)
 222 {
 223         CALLED();
 224         if (fTrackList == NULL || fExtractor == NULL
 225                 || index < 0 || index >= fTrackNum) {
 226                 return NULL;
 227         }
 228         if (fTrackList[index] == NULL) {
 229                 TRACE("BMediaFile::TrackAt, creating new track for index %"
 230                         B_PRId32 "\n", index);
 231                 fTrackList[index] = new(std::nothrow) BMediaTrack(fExtractor, index);
 232                 TRACE("BMediaFile::TrackAt, new track is %p\n", fTrackList[index]);
 233         }
 234         return fTrackList[index];
 235 }
 236
 237
 238 // Release the resource used by a given BMediaTrack object, to reduce
 239 // the memory usage of your application. The specific 'track' object
 240 // can no longer be used, but you can create another one by calling
 241 // TrackAt() with the same track index.
 242 status_t
 243 BMediaFile::ReleaseTrack(BMediaTrack* track)
 244 {
 245         CALLED();
 246         if (!fTrackList || !track)
 247                 return B_ERROR;
 248         for (int32 i = 0; i < fTrackNum; i++) {
 249                 if (fTrackList[i] == track) {
 250                         TRACE("BMediaFile::ReleaseTrack, releasing track %p with index "
 251                                 "%" B_PRId32 "\n", track, i);
 252                         delete track;
 253                         fTrackList[i] = NULL;
 254                         return B_OK;
 255                 }
 256         }
 257         fprintf(stderr, "BMediaFile::ReleaseTrack track %p not found\n", track);
 258         return B_ERROR;
 259 }
 260
 261
 262 status_t
 263 BMediaFile::ReleaseAllTracks()
 264 {
 265         CALLED();
 266         if (!fTrackList)
 267                 return B_ERROR;
 268         for (int32 i = 0; i < fTrackNum; i++) {
 269                 if (fTrackList[i]) {
 270                         TRACE("BMediaFile::ReleaseAllTracks, releasing track %p with "
 271                                 "index %" B_PRId32 "\n", fTrackList[i], i);
 272                         delete fTrackList[i];
 273                         fTrackList[i] = NULL;
 274                 }
 275         }
 276         return B_OK;
 277 }
 278
 279
 280 // Create and add a track to the media file
 281 BMediaTrack*
 282 BMediaFile::CreateTrack(media_format* mediaFormat,
 283         const media_codec_info* codecInfo, uint32 flags)
 284 {
 285         if (mediaFormat == NULL)
 286                 return NULL;
 287
 288         // NOTE: It is allowed to pass NULL for codecInfo. In that case, the
 289         // track won't have an Encoder and you can only use WriteChunk() with
 290         // already encoded data.
 291
 292         // Make room for the new track.
 293         BMediaTrack** trackList = (BMediaTrack**)realloc(fTrackList,
 294                 (fTrackNum + 1) * sizeof(BMediaTrack*));
 295         if (trackList == NULL)
 296                 return NULL;
 297
 298         int32 streamIndex = fTrackNum;
 299         fTrackList = trackList;
 300         fTrackNum += 1;
 301
 302         BMediaTrack* track = new(std::nothrow) BMediaTrack(fWriter, streamIndex,
 303                 mediaFormat, codecInfo);
 304
 305         fTrackList[streamIndex] = track;
 306
 307         return track;
 308 }
 309
 310
 311 // Create and add a raw track to the media file (it has no encoder)
 312 BMediaTrack*
 313 BMediaFile::CreateTrack(media_format* mf, uint32 flags)
 314 {
 315         return CreateTrack(mf, NULL, flags);
 316 }
 317
 318
 319 // For BeOS R5 compatibility
 320 extern "C" BMediaTrack*
 321 CreateTrack__10BMediaFileP12media_formatPC16media_codec_info(
 322         BMediaFile* self, media_format* mf, const media_codec_info* mci);
 323 BMediaTrack*
 324 CreateTrack__10BMediaFileP12media_formatPC16media_codec_info(BMediaFile* self,
 325         media_format* mf, const media_codec_info* mci)
 326 {
 327         return self->CreateTrack(mf, mci, 0);
 328 }
 329
 330
 331 // For BeOS R5 compatibility
 332 extern "C" BMediaTrack* CreateTrack__10BMediaFileP12media_format(
 333         BMediaFile* self, media_format* mf);
 334 BMediaTrack*
 335 CreateTrack__10BMediaFileP12media_format(BMediaFile* self, media_format* mf)
 336 {
 337         return self->CreateTrack(mf, NULL, 0);
 338 }
 339
 340
 341 // Lets you set the copyright info for the entire file
 342 status_t
 343 BMediaFile::AddCopyright(const char* copyright)
 344 {
 345         if (fWriter == NULL)
 346                 return B_NO_INIT;
 347
 348         return fWriter->SetCopyright(copyright);
 349 }
 350
 351
 352 // Call this to add user-defined chunks to a file (if they're supported)
 353 status_t
 354 BMediaFile::AddChunk(int32 type, const void* data, size_t size)
 355 {
 356         UNIMPLEMENTED();
 357         return B_OK;
 358 }
 359
 360
 361 // After you have added all the tracks you want, call this
 362 status_t
 363 BMediaFile::CommitHeader()
 364 {
 365         if (fWriter == NULL)
 366                 return B_NO_INIT;
 367
 368         return fWriter->CommitHeader();
 369 }
 370
 371
 372 // After you have written all the data to the track objects, call this
 373 status_t
 374 BMediaFile::CloseFile()
 375 {
 376         if (fWriter == NULL)
 377                 return B_NO_INIT;
 378
 379         return fWriter->Close();
 380 }
 381
 382 // This is for controlling file format parameters
 383
 384 // returns a copy of the parameter web
 385 status_t
 386 BMediaFile::GetParameterWeb(BParameterWeb** outWeb)
 387 {
 388         UNIMPLEMENTED();
 389         return B_ERROR;
 390 }
 391
 392
 393 // deprecated BeOS R5 API
 394 BParameterWeb*
 395 BMediaFile::Web()
 396 {
 397         UNIMPLEMENTED();
 398         return 0;
 399 }
 400
 401
 402 status_t
 403 BMediaFile::GetParameterValue(int32 id, void* value, size_t* size)
 404 {
 405         UNIMPLEMENTED();
 406         return B_OK;
 407 }
 408
 409
 410 status_t
 411 BMediaFile::SetParameterValue(int32 id, const void* value, size_t size)
 412 {
 413         UNIMPLEMENTED();
 414         return B_OK;
 415 }
 416
 417
 418 BView*
 419 BMediaFile::GetParameterView()
 420 {
 421         UNIMPLEMENTED();
 422         return 0;
 423 }
 424
 425
 426 status_t
 427 BMediaFile::Perform(int32 selector, void* data)
 428 {
 429         UNIMPLEMENTED();
 430         return B_OK;
 431 }
 432
 433
 434 status_t
 435 BMediaFile::ControlFile(int32 selector, void* ioData, size_t size)
 436 {
 437         UNIMPLEMENTED();
 438         return B_ERROR;
 439 }
 440
 441
 442 // #pragma mark - private
 443
 444
 445 void
 446 BMediaFile::_Init()
 447 {
 448         CALLED();
 449
 450         fSource = NULL;
 451         fTrackNum = 0;
 452         fTrackList = NULL;
 453         fExtractor = NULL;
 454         fStreamer = NULL;
 455         fWriter = NULL;
 456         fWriterID = 0;
 457         fErr = B_OK;
 458         fDeleteSource = false;
 459
 460         // not used so far:
 461         fEncoderMgr = NULL;
 462         fWriterMgr = NULL;
 463         fFileClosed = false;
 464 }
 465
 466
 467 void
 468 BMediaFile::_UnInit()
 469 {
 470         ReleaseAllTracks();
 471         free(fTrackList);
 472         fTrackList = NULL;
 473         fTrackNum = 0;
 474
 475         // Tells the extractor to stop its asynchronous processing
 476         // before deleting its source
 477         if (fExtractor != NULL)
 478                 fExtractor->StopProcessing();
 479
 480         if (fDeleteSource) {
 481                 delete fSource;
 482                 fSource = NULL;
 483                 fDeleteSource = false;
 484         }
 485
 486         // Deleting the extractor or writer can cause unloading of the plugins.
 487         // The source must be deleted before that, because it can come from a
 488         // plugin (for example the http_streamer)
 489         delete fExtractor;
 490         fExtractor = NULL;
 491         delete fWriter;
 492         fWriter = NULL;
 493         delete fStreamer;
 494         fStreamer = NULL;
 495 }
 496
 497
 498 void
 499 BMediaFile::_InitReader(BDataIO* source, const BUrl* url, int32 flags)
 500 {
 501         CALLED();
 502
 503         if (source == NULL && url == NULL) {
 504                 fErr = B_NO_MEMORY;
 505                 return;
 506         }
 507
 508         if (source == NULL)
 509                 _InitStreamer(*url, &source);
 510         else if (BFile* file = dynamic_cast<BFile*>(source))
 511                 fErr = file->InitCheck();
 512
 513         if (fErr != B_OK)
 514                 return;
 515
 516         fExtractor = new(std::nothrow) MediaExtractor(source, flags);
 517
 518         if (fExtractor == NULL)
 519                 fErr = B_NO_MEMORY;
 520         else
 521                 fErr = fExtractor->InitCheck();
 522
 523         if (fErr != B_OK)
 524                 return;
 525
 526         // Get the actual source from the extractor
 527         fSource = fExtractor->Source();
 528
 529         fExtractor->GetFileFormatInfo(&fMFI);
 530         fTrackNum = fExtractor->StreamCount();
 531         fTrackList = (BMediaTrack**)malloc(fTrackNum * sizeof(BMediaTrack*));
 532         if (fTrackList == NULL) {
 533                 fErr = B_NO_MEMORY;
 534                 return;
 535         }
 536         memset(fTrackList, 0, fTrackNum * sizeof(BMediaTrack*));
 537 }
 538
 539
 540 void
 541 BMediaFile::_InitWriter(BDataIO* target, const BUrl* url,
 542         const media_file_format* fileFormat, int32 flags)
 543 {
 544         CALLED();
 545
 546         if (fileFormat == NULL) {
 547                 fErr = B_BAD_VALUE;
 548                 return;
 549         }
 550
 551         if (target == NULL && url == NULL) {
 552                 fErr = B_NO_MEMORY;
 553                 return;
 554         }
 555
 556         fMFI = *fileFormat;
 557
 558         if (target == NULL) {
 559                 _InitStreamer(*url, &target);
 560                 if (fErr != B_OK)
 561                         return;
 562         }
 563
 564         fWriter = new(std::nothrow) MediaWriter(target, fMFI);
 565
 566         if (fWriter == NULL)
 567                 fErr = B_NO_MEMORY;
 568         else
 569                 fErr = fWriter->InitCheck();
 570         if (fErr != B_OK)
 571                 return;
 572
 573         // Get the actual source from the writer
 574         fSource = fWriter->Target();
 575         fTrackNum = 0;
 576 }
 577
 578
 579 void
 580 BMediaFile::_InitStreamer(const BUrl& url, BDataIO** adapter)
 581 {
 582         if (fStreamer != NULL)
 583                 delete fStreamer;
 584
 585         TRACE(url.UrlString());
 586
 587         fStreamer = new(std::nothrow) MediaStreamer(url);
 588         if (fStreamer == NULL) {
 589                 fErr = B_NO_MEMORY;
 590                 return;
 591         }
 592
 593         fErr = fStreamer->CreateAdapter(adapter);
 594 }
 595
 596 /*
 597 //unimplemented
 598 BMediaFile::BMediaFile();
 599 BMediaFile::BMediaFile(const BMediaFile&);
 600  BMediaFile::BMediaFile& operator=(const BMediaFile&);
 601 */
 602
 603 status_t BMediaFile::_Reserved_BMediaFile_0(int32 arg, ...) { return B_ERROR; }
 604 status_t BMediaFile::_Reserved_BMediaFile_1(int32 arg, ...) { return B_ERROR; }
 605 status_t BMediaFile::_Reserved_BMediaFile_2(int32 arg, ...) { return B_ERROR; }
 606 status_t BMediaFile::_Reserved_BMediaFile_3(int32 arg, ...) { return B_ERROR; }
 607 status_t BMediaFile::_Reserved_BMediaFile_4(int32 arg, ...) { return B_ERROR; }
 608 status_t BMediaFile::_Reserved_BMediaFile_5(int32 arg, ...) { return B_ERROR; }
 609 status_t BMediaFile::_Reserved_BMediaFile_6(int32 arg, ...) { return B_ERROR; }
 610 status_t BMediaFile::_Reserved_BMediaFile_7(int32 arg, ...) { return B_ERROR; }
 611 status_t BMediaFile::_Reserved_BMediaFile_8(int32 arg, ...) { return B_ERROR; }
 612 status_t BMediaFile::_Reserved_BMediaFile_9(int32 arg, ...) { return B_ERROR; }
 613 status_t BMediaFile::_Reserved_BMediaFile_10(int32 arg, ...) { return B_ERROR; }
 614 status_t BMediaFile::_Reserved_BMediaFile_11(int32 arg, ...) { return B_ERROR; }
 615 status_t BMediaFile::_Reserved_BMediaFile_12(int32 arg, ...) { return B_ERROR; }
 616 status_t BMediaFile::_Reserved_BMediaFile_13(int32 arg, ...) { return B_ERROR; }
 617 status_t BMediaFile::_Reserved_BMediaFile_14(int32 arg, ...) { return B_ERROR; }
 618 status_t BMediaFile::_Reserved_BMediaFile_15(int32 arg, ...) { return B_ERROR; }
 619 status_t BMediaFile::_Reserved_BMediaFile_16(int32 arg, ...) { return B_ERROR; }
 620 status_t BMediaFile::_Reserved_BMediaFile_17(int32 arg, ...) { return B_ERROR; }
 621 status_t BMediaFile::_Reserved_BMediaFile_18(int32 arg, ...) { return B_ERROR; }
 622 status_t BMediaFile::_Reserved_BMediaFile_19(int32 arg, ...) { return B_ERROR; }
 623 status_t BMediaFile::_Reserved_BMediaFile_20(int32 arg, ...) { return B_ERROR; }
 624 status_t BMediaFile::_Reserved_BMediaFile_21(int32 arg, ...) { return B_ERROR; }
 625 status_t BMediaFile::_Reserved_BMediaFile_22(int32 arg, ...) { return B_ERROR; }
 626 status_t BMediaFile::_Reserved_BMediaFile_23(int32 arg, ...) { return B_ERROR; }
 627 status_t BMediaFile::_Reserved_BMediaFile_24(int32 arg, ...) { return B_ERROR; }
 628 status_t BMediaFile::_Reserved_BMediaFile_25(int32 arg, ...) { return B_ERROR; }
 629 status_t BMediaFile::_Reserved_BMediaFile_26(int32 arg, ...) { return B_ERROR; }
 630 status_t BMediaFile::_Reserved_BMediaFile_27(int32 arg, ...) { return B_ERROR; }
 631 status_t BMediaFile::_Reserved_BMediaFile_28(int32 arg, ...) { return B_ERROR; }
 632 status_t BMediaFile::_Reserved_BMediaFile_29(int32 arg, ...) { return B_ERROR; }
 633 status_t BMediaFile::_Reserved_BMediaFile_30(int32 arg, ...) { return B_ERROR; }
 634 status_t BMediaFile::_Reserved_BMediaFile_31(int32 arg, ...) { return B_ERROR; }
 635 status_t BMediaFile::_Reserved_BMediaFile_32(int32 arg, ...) { return B_ERROR; }
 636 status_t BMediaFile::_Reserved_BMediaFile_33(int32 arg, ...) { return B_ERROR; }
 637 status_t BMediaFile::_Reserved_BMediaFile_34(int32 arg, ...) { return B_ERROR; }
 638 status_t BMediaFile::_Reserved_BMediaFile_35(int32 arg, ...) { return B_ERROR; }
 639 status_t BMediaFile::_Reserved_BMediaFile_36(int32 arg, ...) { return B_ERROR; }
 640 status_t BMediaFile::_Reserved_BMediaFile_37(int32 arg, ...) { return B_ERROR; }
 641 status_t BMediaFile::_Reserved_BMediaFile_38(int32 arg, ...) { return B_ERROR; }
 642 status_t BMediaFile::_Reserved_BMediaFile_39(int32 arg, ...) { return B_ERROR; }
 643 status_t BMediaFile::_Reserved_BMediaFile_40(int32 arg, ...) { return B_ERROR; }
 644 status_t BMediaFile::_Reserved_BMediaFile_41(int32 arg, ...) { return B_ERROR; }
 645 status_t BMediaFile::_Reserved_BMediaFile_42(int32 arg, ...) { return B_ERROR; }
 646 status_t BMediaFile::_Reserved_BMediaFile_43(int32 arg, ...) { return B_ERROR; }
 647 status_t BMediaFile::_Reserved_BMediaFile_44(int32 arg, ...) { return B_ERROR; }
 648 status_t BMediaFile::_Reserved_BMediaFile_45(int32 arg, ...) { return B_ERROR; }
 649 status_t BMediaFile::_Reserved_BMediaFile_46(int32 arg, ...) { return B_ERROR; }
 650 status_t BMediaFile::_Reserved_BMediaFile_47(int32 arg, ...) { return B_ERROR; }
 651