Ticket #7476: mediaplayer_playlist_enhancement.diff

File mediaplayer_playlist_enhancement.diff, 20.9 KB (added by shinta, 9 years ago)

This is the patch.

  • playlist/Playlist.cpp

     
    514514        if (_IsMediaFile(mimeString)) {
    515515            PlaylistItem* item = new (std::nothrow) FilePlaylistItem(ref);
    516516            if (!ExtraMediaExists(playlist, ref)) {
    517                 _BindExtraMedia(item);
     517                _BindExtraMediaAndSubTitles(item);
    518518                if (item != NULL && !playlist->AddItem(item))
    519519                    delete item;
    520520            } else
     
    594594/*static*/ bool
    595595Playlist::ExtraMediaExists(Playlist* playlist, const entry_ref& ref)
    596596{
    597     BString exceptExtension = _GetExceptExtension(BPath(&ref).Path());
     597    BString exceptExtension = FilePlaylistItem::GetExceptExtension(BPath(&ref).Path());
    598598   
    599599    for (int32 i = 0; i < playlist->CountItems(); i++) {
    600600        FilePlaylistItem* compare = dynamic_cast<FilePlaylistItem*>(playlist->ItemAt(i));
    601601        if (compare == NULL)
    602602            continue;
    603603        if (compare->Ref() != ref
    604                 && _GetExceptExtension(BPath(&compare->Ref()).Path()) == exceptExtension )
     604                && FilePlaylistItem::GetExceptExtension(BPath(&compare->Ref()).Path()) == exceptExtension )
    605605            return true;
    606606    }
    607607    return false;
     
    708708}
    709709
    710710
    711 // _BindExtraMedia() searches additional videos and audios
    712 // and addes them as extra medias.
     711// _BindExtraMediaAndSubTitle() searches additional videos, audios, images, and subtitles.
    713712/*static*/ void
    714 Playlist::_BindExtraMedia(PlaylistItem* item)
     713Playlist::_BindExtraMediaAndSubTitles(PlaylistItem* item)
    715714{
    716715    FilePlaylistItem* fileItem = dynamic_cast<FilePlaylistItem*>(item);
    717716    if (!item)
    718717        return;
    719718   
    720     // If the media file is foo.mp3, _BindExtraMedia() searches foo.avi.
    721719    BPath mediaFilePath(&fileItem->Ref());
    722720    BString mediaFilePathString = mediaFilePath.Path();
     721    BString mediaFilePathStringExceptExtension
     722            = FilePlaylistItem::GetExceptExtension(mediaFilePathString);
    723723    BPath dirPath;
    724724    mediaFilePath.GetParent(&dirPath);
    725725    BDirectory dir(dirPath.Path());
     
    728728   
    729729    BEntry entry;
    730730    BString entryPathString;
     731    BString entryPathStringExceptExtension;
     732    BString entryPathStringExtension;
    731733    while (dir.GetNextEntry(&entry, true) == B_OK) {
    732734        if (!entry.IsFile())
    733735            continue;
    734736        entryPathString = BPath(&entry).Path();
    735         if (entryPathString != mediaFilePathString
    736                 && _GetExceptExtension(entryPathString) == _GetExceptExtension(mediaFilePathString)) {
    737             _BindExtraMedia(fileItem, entry);
     737        entryPathStringExceptExtension = FilePlaylistItem::GetExceptExtension(entryPathString);
     738        entryPathStringExtension = FilePlaylistItem::GetExtension(entryPathString);
     739        if (entryPathString != mediaFilePathString) {
     740            if (entryPathStringExtension == "srt"
     741                    && entryPathStringExceptExtension.FindFirst(mediaFilePathStringExceptExtension) != B_ERROR) {
     742                // Adds foo.langName.srt as subtitle
     743                _BindSubTitles(fileItem, entry);
     744            } else if (entryPathStringExceptExtension == mediaFilePathStringExceptExtension) {
     745                // Add audio/video/image as extra media
     746                _BindExtraMedia(fileItem, entry);
     747            }
    738748        }
    739749    }
    740750}
     
    754764}
    755765
    756766
    757 /*static*/ BString
    758 Playlist::_GetExceptExtension(const BString& path)
     767/*static*/  void
     768Playlist::_BindSubTitles(FilePlaylistItem* fileItem, const BEntry& entry)
    759769{
    760     int32 periodPos = path.FindLast('.');
    761     if (periodPos <= path.FindLast('/'))
    762         return path;
    763     return BString(path.String(), periodPos);
     770    entry_ref ref;
     771    entry.GetRef(&ref);
     772   
     773    fileItem->AddSubTitlesRef(ref);
    764774}
    765775
    766776
  • playlist/Playlist.h

     
    128128    static  bool                _IsPlaylist(const BString& mimeString);
    129129    static  bool                _IsQuery(const BString& mimeString);
    130130    static  BString             _MIMEString(const entry_ref* ref);
    131     static  void                _BindExtraMedia(PlaylistItem* item);
     131    static  void                _BindExtraMediaAndSubTitles(PlaylistItem* item);
    132132    static  void                _BindExtraMedia(FilePlaylistItem* fileItem, const BEntry& entry);
    133     static  BString             _GetExceptExtension(const BString& path);
     133    static  void                _BindSubTitles(FilePlaylistItem* fileItem, const BEntry& entry);
    134134
    135135            void                _NotifyItemAdded(PlaylistItem*,
    136136                                    int32 index) const;
  • playlist/FilePlaylistItem.cpp

     
    2020#include "SubTitlesSRT.h"
    2121
    2222static const char* kPathKey = "path";
     23static const char* kImagePathKey = "imagePath";
     24static const char* kSubTitlesPathKey = "subTitlesPath";
    2325
    2426FilePlaylistItem::FilePlaylistItem(const entry_ref& ref)
    2527{
     
    2830}
    2931
    3032
    31 FilePlaylistItem::FilePlaylistItem(const FilePlaylistItem& other)
    32     :
    33     fRefs(other.fRefs),
    34     fNamesInTrash(other.fNamesInTrash),
    35     fImageRefs(other.fImageRefs),
    36     fImageNamesInTrash(other.fImageNamesInTrash)
    37 {
    38 }
    39 
    40 
    4133FilePlaylistItem::FilePlaylistItem(const BMessage* archive)
    4234{
    43     const char* path;
    44     entry_ref   ref;
    4535    if (archive != NULL) {
    46         int32 i = 0;
    47         while (archive->FindString(kPathKey, i, &path) == B_OK) {
    48             if (get_ref_for_path(path, &ref) == B_OK) {
    49                 fRefs.push_back(ref);
    50             }
    51             i++;
    52         }
     36        _Unarchive(archive, kPathKey, &fRefs);
     37        _Unarchive(archive, kImagePathKey, &fImageRefs);
     38        _Unarchive(archive, kSubTitlesPathKey, &fSubTitlesRefs);
    5339    }
    5440    if (fRefs.empty()) {
    5541        fRefs.push_back(entry_ref());
     
    5743    for (vector<entry_ref>::size_type i = 0; i < fRefs.size(); i++) {
    5844        fNamesInTrash.push_back("");
    5945    }
     46    for (vector<entry_ref>::size_type i = 0; i < fImageRefs.size(); i++) {
     47        fImageNamesInTrash.push_back("");
     48    }
     49    for (vector<entry_ref>::size_type i = 0; i < fSubTitlesRefs.size(); i++) {
     50        fSubTitlesNamesInTrash.push_back("");
     51    }
    6052}
    6153
    6254
     
    7264}
    7365
    7466
     67/*static*/ BString
     68FilePlaylistItem::GetExceptExtension(const BString& path)
     69{
     70    int32 periodPos = path.FindLast('.');
     71    if (periodPos <= path.FindLast('/'))
     72        return path;
     73    return BString(path.String(), periodPos);
     74}
     75
     76
     77/*static*/ BString
     78FilePlaylistItem::GetExtension(const BString& path)
     79{
     80    int32 periodPos = path.FindLast('.');
     81    if (periodPos <= path.FindLast('/'))
     82        return BString();
     83    return BString(path.String() + periodPos + 1).ToLower();
     84}
     85
     86
    7587BArchivable*
    7688FilePlaylistItem::Instantiate(BMessage* archive)
    7789{
     
    91103    status_t ret = BArchivable::Archive(into, deep);
    92104    if (ret != B_OK)
    93105        return ret;
    94     for (vector<entry_ref>::size_type i = 0; i < fRefs.size(); i++) {
    95         BPath path(&fRefs[i]);
    96         ret = path.InitCheck();
    97         if (ret != B_OK)
    98             return ret;
    99         ret = into->AddString(kPathKey, path.Path());
    100         if (ret != B_OK)
    101             return ret;
    102     }
     106
     107    ret = _Archive(into, deep, kPathKey, fRefs);
     108    if (ret != B_OK)
     109        return ret;
     110
     111    ret = _Archive(into, deep, kImagePathKey, fImageRefs);
     112    if (ret != B_OK)
     113        return ret;
     114
     115    ret = _Archive(into, deep, kSubTitlesPathKey, fSubTitlesRefs);
     116    if (ret != B_OK)
     117        return ret;
     118
    103119    return B_OK;
    104120}
    105121
     
    233249    }
    234250
    235251    status_t err;
    236     err = _MoveIntoTrash(&fRefs, &fNamesInTrash);
     252    err = _MoveIntoTrash(fRefs, &fNamesInTrash);
    237253    if (err != B_OK)
    238254        return err;
    239255   
    240     if (fImageRefs.empty())
    241         return B_OK;
     256    if (!fImageRefs.empty()) {
     257        err = _MoveIntoTrash(fImageRefs, &fImageNamesInTrash);
     258        if (err != B_OK)
     259            return err;
     260    }
    242261
    243     err = _MoveIntoTrash(&fImageRefs, &fImageNamesInTrash);
    244     if (err != B_OK)
    245         return err;
     262    if (!fSubTitlesRefs.empty()) {
     263        err = _MoveIntoTrash(fSubTitlesRefs, &fSubTitlesNamesInTrash);
     264        if (err != B_OK)
     265            return err;
     266    }
    246267
    247268    return B_OK;
    248269}
     
    257278    }
    258279
    259280    status_t err;
    260     err = _RestoreFromTrash(&fRefs, &fNamesInTrash);
     281    err = _RestoreFromTrash(fRefs, &fNamesInTrash);
    261282    if (err != B_OK)
    262283        return err;
    263284   
    264     if (fImageRefs.empty())
    265         return B_OK;
     285    if (!fImageRefs.empty()) {
     286        err = _RestoreFromTrash(fImageRefs, &fImageNamesInTrash);
     287        if (err != B_OK)
     288            return err;
     289    }
    266290
    267     err = _RestoreFromTrash(&fImageRefs, &fImageNamesInTrash);
    268     if (err != B_OK)
    269         return err;
     291    if (!fSubTitlesRefs.empty()) {
     292        err = _RestoreFromTrash(fSubTitlesRefs, &fSubTitlesNamesInTrash);
     293        if (err != B_OK)
     294            return err;
     295    }
    270296
    271297    return B_OK;
    272298}
     
    282308    if (supplier == NULL)
    283309        return NULL;
    284310
     311    // Audio/Video
    285312    for (vector<entry_ref>::size_type i = 0; i < fRefs.size(); i++) {
    286313        BMediaFile* mediaFile = new(std::nothrow) BMediaFile(&fRefs[i]);
    287         if (mediaFile == NULL) {
    288             delete supplier;
    289             return NULL;
    290         }
     314        if (mediaFile == NULL)
     315            continue;
    291316        if (supplier->AddMediaFile(mediaFile) != B_OK)
    292317            delete mediaFile;
    293318    }
     319    if (supplier->CountAudioTracks() + supplier->CountVideoTracks() == 0) {
     320        delete supplier;
     321        return NULL;
     322    }
    294323
     324    // Artwork
    295325    for (vector<entry_ref>::size_type i = 0; i < fImageRefs.size(); i++) {
    296326        BBitmap* bitmap = BTranslationUtils::GetBitmap(&fImageRefs[i]);
    297327        if (bitmap == NULL)
     
    300330            delete bitmap;
    301331    }
    302332
    303     // Search for subtitle files in the same folder
    304     // TODO: Error checking
    305     BEntry entry(&fRefs[0], true);
     333    // Subtitle
     334    for (vector<entry_ref>::size_type i = 0; i < fSubTitlesRefs.size(); i++) {
     335        BString language = GetExtension(GetExceptExtension(BPath(&fSubTitlesRefs[i]).Path()));
     336        if (language.Length() == 0) {
     337            language = "default";
     338        }
    306339
    307     char originalName[B_FILE_NAME_LENGTH];
    308     entry.GetName(originalName);
    309     BString nameWithoutExtension(originalName);
    310     int32 extension = nameWithoutExtension.FindLast('.');
    311     if (extension > 0)
    312         nameWithoutExtension.Truncate(extension);
    313 
    314     BPath path;
    315     entry.GetPath(&path);
    316     path.GetParent(&path);
    317     BDirectory directory(path.Path());
    318     while (directory.GetNextEntry(&entry) == B_OK) {
    319         char name[B_FILE_NAME_LENGTH];
    320         if (entry.GetName(name) != B_OK)
     340        SubTitles* subTitles
     341            = new(std::nothrow) SubTitlesSRT(&fSubTitlesRefs[i], language.String());
     342        if (subTitles == NULL)
    321343            continue;
    322         BString nameString(name);
    323         if (nameString == originalName)
    324             continue;
    325         if (nameString.IFindFirst(nameWithoutExtension) < 0)
    326             continue;
    327 
    328         BFile file(&entry, B_READ_ONLY);
    329         if (file.InitCheck() != B_OK)
    330             continue;
    331 
    332         int32 pos = nameString.FindLast('.');
    333         if (pos < 0)
    334             continue;
    335 
    336         BString extensionString(nameString.String() + pos + 1);
    337         extensionString.ToLower();
    338 
    339         BString language = "default";
    340         if (pos > 1) {
    341             int32 end = pos;
    342             while (pos > 0 && *(nameString.String() + pos - 1) != '.')
    343                 pos--;
    344             language.SetTo(nameString.String() + pos, end - pos);
    345         }
    346 
    347         if (extensionString == "srt") {
    348             SubTitles* subTitles
    349                 = new(std::nothrow) SubTitlesSRT(&file, language.String());
    350             if (subTitles != NULL && !supplier->AddSubTitles(subTitles))
    351                 delete subTitles;
    352         }
     344        if (supplier->AddSubTitles(subTitles) != B_OK)
     345            delete subTitles;
    353346    }
    354347
    355348    return supplier;
     
    365358}
    366359
    367360
     361const entry_ref&
     362FilePlaylistItem::Ref(int32 index) const
     363{
     364    static entry_ref ref;
     365
     366    if (index >= static_cast<int32>(fRefs.size()))
     367        return ref;
     368   
     369    return fRefs[index];
     370}
     371
     372
    368373status_t
    369374FilePlaylistItem::AddImageRef(const entry_ref& ref)
    370375{
     
    375380
    376381
    377382const entry_ref&
    378 FilePlaylistItem::ImageRef() const
     383FilePlaylistItem::ImageRef(int32 index) const
    379384{
    380385    static entry_ref ref;
    381386
    382     if (fImageRefs.empty())
     387    if (index >= static_cast<int32>(fImageRefs.size()))
    383388        return ref;
    384389   
    385     return fImageRefs[0];
     390    return fImageRefs[index];
    386391}
    387392
    388393
    389394status_t
     395FilePlaylistItem::AddSubTitlesRef(const entry_ref& ref)
     396{
     397    fSubTitlesRefs.push_back(ref);
     398    fSubTitlesNamesInTrash.push_back("");
     399    return B_OK;
     400}
     401
     402
     403const entry_ref&
     404FilePlaylistItem::SubTitlesRef(int32 index) const
     405{
     406    static entry_ref ref;
     407
     408    if (index >= static_cast<int32>(fSubTitlesRefs.size()))
     409        return ref;
     410   
     411    return fSubTitlesRefs[index];
     412}
     413
     414
     415status_t
     416FilePlaylistItem::_Archive(BMessage* into, bool deep,
     417    const char* pathKey,
     418    const vector<entry_ref>& refs) const
     419{
     420    for (vector<entry_ref>::size_type i = 0; i < refs.size(); i++) {
     421        BPath path(&refs[i]);
     422        status_t ret = path.InitCheck();
     423        if (ret != B_OK)
     424            return ret;
     425        ret = into->AddString(pathKey, path.Path());
     426        if (ret != B_OK)
     427            return ret;
     428    }
     429    return B_OK;
     430}
     431
     432
     433status_t
     434FilePlaylistItem::_Unarchive(const BMessage* archive,
     435    const char* pathKey,
     436    vector<entry_ref>* refs) const
     437{
     438    const char* path;
     439    int32 i = 0;
     440    while (archive->FindString(pathKey, i, &path) == B_OK) {
     441        entry_ref ref;
     442        if (get_ref_for_path(path, &ref) == B_OK) {
     443            refs->push_back(ref);
     444        }
     445        i++;
     446    }
     447    return B_OK;
     448}
     449
     450
     451status_t
    390452FilePlaylistItem::_SetAttribute(const char* attrName, type_code type,
    391     const void* data, size_t size)
     453    const void* data, size_t size) const
    392454{
    393455    BEntry entry(&fRefs[0], true);
    394456    BNode node(&entry);
     
    407469
    408470status_t
    409471FilePlaylistItem::_GetAttribute(const char* attrName, type_code type,
    410     void* data, size_t size)
     472    void* data, size_t size) const
    411473{
    412474    BEntry entry(&fRefs[0], true);
    413475    BNode node(&entry);
     
    425487
    426488
    427489status_t
    428 FilePlaylistItem::_MoveIntoTrash(vector<entry_ref>* refs,
    429     vector<BString>* namesInTrash)
     490FilePlaylistItem::_MoveIntoTrash(const vector<entry_ref>& refs,
     491    vector<BString>* namesInTrash) const
    430492{
    431493    char trashPath[B_PATH_NAME_LENGTH];
    432     status_t err = find_directory(B_TRASH_DIRECTORY, (*refs)[0].device,
     494    status_t err = find_directory(B_TRASH_DIRECTORY, refs[0].device,
    433495        true /*create it*/, trashPath, B_PATH_NAME_LENGTH);
    434496    if (err != B_OK) {
    435497        fprintf(stderr, "failed to find Trash: %s\n", strerror(err));
     
    443505        return err;
    444506    }
    445507
    446     for (vector<entry_ref>::size_type i = 0; i < refs->size(); i++) {
    447         BEntry entry(&(*refs)[i]);
     508    for (vector<entry_ref>::size_type i = 0; i < refs.size(); i++) {
     509        BEntry entry(&refs[i]);
    448510        err = entry.InitCheck();
    449511        if (err != B_OK) {
    450512            fprintf(stderr, "failed to init BEntry for %s: %s\n",
    451                 (*refs)[i].name, strerror(err));
     513                refs[i].name, strerror(err));
    452514            return err;
    453515        }
    454516   
    455517        // Find a unique name for the entry in the trash
    456         (*namesInTrash)[i] = (*refs)[i].name;
     518        (*namesInTrash)[i] = refs[i].name;
    457519        int32 uniqueNameIndex = 1;
    458520        while (true) {
    459521            BEntry test(&trashDir, (*namesInTrash)[i].String());
    460522            if (!test.Exists())
    461523                break;
    462             (*namesInTrash)[i] = (*refs)[i].name;
     524            (*namesInTrash)[i] = refs[i].name;
    463525            (*namesInTrash)[i] << ' ' << uniqueNameIndex;
    464526            uniqueNameIndex++;
    465527        }
     
    487549
    488550
    489551status_t
    490 FilePlaylistItem::_RestoreFromTrash(vector<entry_ref>* refs,
    491     vector<BString>* namesInTrash)
     552FilePlaylistItem::_RestoreFromTrash(const vector<entry_ref>& refs,
     553    vector<BString>* namesInTrash) const
    492554{
    493555    char trashPath[B_PATH_NAME_LENGTH];
    494     status_t err = find_directory(B_TRASH_DIRECTORY, (*refs)[0].device,
     556    status_t err = find_directory(B_TRASH_DIRECTORY, refs[0].device,
    495557        false /*create it*/, trashPath, B_PATH_NAME_LENGTH);
    496558    if (err != B_OK) {
    497559        fprintf(stderr, "failed to find Trash: %s\n", strerror(err));
    498560        return err;
    499561    }
    500562   
    501     for (vector<entry_ref>::size_type i = 0; i < refs->size(); i++) {
     563    for (vector<entry_ref>::size_type i = 0; i < refs.size(); i++) {
    502564        // construct the entry to the file in the trash
    503565        // TODO: BEntry(const BDirectory* directory, const char* path) is broken!
    504566        //  BEntry entry(trashPath, (*namesInTrash)[i].String());
     
    515577   
    516578        // construct the folder of the original entry_ref
    517579        node_ref nodeRef;
    518         nodeRef.device = (*refs)[i].device;
    519         nodeRef.node = (*refs)[i].directory;
     580        nodeRef.device = refs[i].device;
     581        nodeRef.node = refs[i].directory;
    520582        BDirectory originalDir(&nodeRef);
    521583        err = originalDir.InitCheck();
    522584        if (err != B_OK) {
    523585            fprintf(stderr, "failed to init original BDirectory for "
    524                 "%s: %s\n", (*refs)[i].name, strerror(err));
     586                "%s: %s\n", refs[i].name, strerror(err));
    525587            return err;
    526588        }
    527589   
     
    533595        (*namesInTrash)[i] = "";
    534596   
    535597        // Finally, move the entry back into the original folder
    536         err = entry.MoveTo(&originalDir, (*refs)[i].name);
     598        err = entry.MoveTo(&originalDir, refs[i].name);
    537599        if (err != B_OK) {
    538600            fprintf(stderr, "failed to restore entry from trash "
    539                 "%s: %s\n", (*refs)[i].name, strerror(err));
     601                "%s: %s\n", refs[i].name, strerror(err));
    540602            return err;
    541603        }
    542604   
  • playlist/FilePlaylistItem.h

     
    1717class FilePlaylistItem : public PlaylistItem {
    1818public:
    1919                                FilePlaylistItem(const entry_ref& ref);
    20                                 FilePlaylistItem(const FilePlaylistItem& item);
    2120                                FilePlaylistItem(const BMessage* archive);
    2221    virtual                     ~FilePlaylistItem();
    2322
    2423    virtual PlaylistItem*       Clone() const;
    2524
     25    // filename utility
     26    static  BString             GetExceptExtension(const BString& path);
     27    static  BString             GetExtension(const BString& path);
     28
    2629    // archiving
    2730    static  BArchivable*        Instantiate(BMessage* archive);
    2831    virtual status_t            Archive(BMessage* into,
     
    5659    virtual TrackSupplier*      CreateTrackSupplier() const;
    5760
    5861            status_t            AddRef(const entry_ref& ref);
    59             const entry_ref&    Ref() const { return fRefs[0]; }
     62            const entry_ref&    Ref(int32 index = 0) const;
    6063
    6164            status_t            AddImageRef(const entry_ref& ref);
    62             const entry_ref&    ImageRef() const;
     65            const entry_ref&    ImageRef(int32 index = 0) const;
    6366
     67            status_t            AddSubTitlesRef(const entry_ref& ref);
     68            const entry_ref&    SubTitlesRef(int32 index = 0) const;
     69
    6470private:
     71    virtual status_t            _Archive(BMessage* into, bool deep,
     72                                    const char* pathKey,
     73                                    const vector<entry_ref>& refs) const;
     74            status_t            _Unarchive(const BMessage* archive,
     75                                    const char* pathKey,
     76                                    vector<entry_ref>* refs) const;
    6577            status_t            _SetAttribute(const char* attrName,
    6678                                    type_code type, const void* data,
    67                                     size_t size);
     79                                    size_t size) const;
    6880            status_t            _GetAttribute(const char* attrName,
    6981                                    type_code type, void* data,
    70                                     size_t size);
    71             status_t            _MoveIntoTrash(vector<entry_ref>* refs,
    72                                     vector<BString>* namesInTrash);
    73             status_t            _RestoreFromTrash(vector<entry_ref>* refs,
    74                                     vector<BString>* namesInTrash);
     82                                    size_t size) const;
     83            status_t            _MoveIntoTrash(const vector<entry_ref>& refs,
     84                                    vector<BString>* namesInTrash) const;
     85            status_t            _RestoreFromTrash(const vector<entry_ref>& refs,
     86                                    vector<BString>* namesInTrash) const;
    7587
    7688private:
    77     // always fRefs.size() == fNamesInTrash.size()
     89    // Audio/Video refs: always fRefs.size() == fNamesInTrash.size()
    7890            vector<entry_ref>   fRefs;
    7991            vector<BString>     fNamesInTrash;
    80     // always fImageRefs.size() == fImageNamesInTrash.size()
     92    // Artwork refs: always fImageRefs.size() == fImageNamesInTrash.size()
    8193            vector<entry_ref>   fImageRefs;
    8294            vector<BString>     fImageNamesInTrash;
     95    // Subtitles refs: always fSubTitlesRefs.size() == fSubTitlesNamesInTrash.size()
     96            vector<entry_ref>   fSubTitlesRefs;
     97            vector<BString>     fSubTitlesNamesInTrash;
    8398};
    8499
    85100#endif // FILE_PLAYLIST_ITEM_H
  • supplier/SubTitlesSRT.cpp

     
    1515#include "FileReadWrite.h"
    1616
    1717
    18 SubTitlesSRT::SubTitlesSRT(BFile* file, const char* name)
     18SubTitlesSRT::SubTitlesSRT(const entry_ref* ref, const char* name)
    1919    :
    2020    SubTitles(),
    2121    fName(name),
    2222    fSubTitles(64)
    2323{
    24     if (file == NULL)
     24    if (ref == NULL)
    2525        return;
    26     if (file->InitCheck() != B_OK)
     26
     27    BFile file(ref, B_READ_ONLY);
     28    if (file.InitCheck() != B_OK)
    2729        return;
    2830
    29     FileReadWrite lineProvider(file);
     31    FileReadWrite lineProvider(&file);
    3032    BString line;
    3133    enum {
    3234        EXPECT_SEQUENCE_NUMBER = 0,
  • supplier/SubTitlesSRT.h

     
    66#define SUB_TITLES_SRT_H
    77
    88
     9#include <Entry.h>
    910#include <List.h>
    1011
    1112#include "SubTitles.h"
     
    1617
    1718class SubTitlesSRT : public SubTitles {
    1819public:
    19                                 SubTitlesSRT(BFile* file, const char* name);
     20                                SubTitlesSRT(const entry_ref* ref, const char* name);
    2021    virtual                     ~SubTitlesSRT();
    2122
    2223    virtual const char*         Name() const;
  • supplier/MediaFileTrackSupplier.cpp

     
    176176}
    177177
    178178
    179 bool
     179status_t
    180180MediaFileTrackSupplier::AddSubTitles(SubTitles* subTitles)
    181181{
    182     return fSubTitleTracks.AddItem(subTitles);
     182    return fSubTitleTracks.AddItem(subTitles) ? B_OK : B_ERROR;
    183183}
    184184
    185185
  • supplier/MediaFileTrackSupplier.h

     
    4242    virtual VideoTrackSupplier* CreateVideoTrackForIndex(int32 index);
    4343    virtual const SubTitles*    SubTitleTrackForIndex(int32 index);
    4444
    45             bool                AddSubTitles(SubTitles* subTitles);
     45            status_t            AddSubTitles(SubTitles* subTitles);
    4646
    4747            status_t            AddMediaFile(BMediaFile* mediaFile);
    4848