下載TS檔案片段

處理完Master PlayList和Media PlayList之後就可以開始下載TS視訊片段了

下載的流程如下：

1、初始化本地的檔名

2、設定本地檔案的訪問許可權

3、建立任務佇列

4、建立PlayList更新執行緒，因為伺服器上的m3u8檔案可能會經過改動，因此需要實時更新

5、遍歷任務佇列，佇列裡面存放的是TS媒體檔案的資訊，根據這些資訊，下載TS視訊檔案。另外，如果下載的檔案的大小已經超過了最大的檔案的大小，那麼表示伺服器上的m3u8檔案已經修改，需要更新PlayList

// 下載TS檔案
int download_hls(struct hls_media_playlist *me,bool live_streamming,int max_file_size,const char* custom_filename, std::string user_agent, bool force_overwrite=true)
{
    if(live_streamming){
        MSG_VERBOSE("Downloading Live Streaming\n");
    }else{
        MSG_VERBOSE("Downloading %d segments.\n", me->count);
    }

    char filename[MAX_FILENAME_LEN];

	// 初始化本地檔名
    if (custom_filename!=NULL && *custom_filename!='\0') {
        strcpy(filename, custom_filename);
    } else {
        strcpy(filename, "000_hls_output.ts");
    }

	// 訪問許可權的設定
    if (access(filename, F_OK) != -1) {
        if (force_overwrite) {
            if (remove(filename) != 0) {
                MSG_ERROR("Error overwriting file");
                exit(1);
            }
        } else {
            char userchoice;
            MSG_PRINT("File already exists. Overwrite? (y/n) ");
            scanf("\n%c", &userchoice);
            if (userchoice == 'y') {
                if (remove(filename) != 0) {
                    MSG_ERROR("Error overwriting file");
                    exit(1);
                }
            } else {
                MSG_WARNING("Choose a different filename. Exiting.\n");
                exit(0);
            }
        }
    }

	// 建立任務佇列
    std::shared_ptr<Queue<std::shared_ptr<hls_media_segment>>> segment_queue(new Queue<std::shared_ptr<hls_media_segment>>());
    std::mutex mutex_;
    std::condition_variable cond_;
    bool flag_finish=false;

    int lattest_sequence_number=-1;
	
	// 更新PlayList的執行緒，伺服器上的m3u8檔案可能更新得很頻繁
    std::shared_ptr<std::thread> update_playlist_thread=std::make_shared<std::thread>([&]{    
        bool first_download_iteration = true;
        int wait_second= me->target_duration > 0 ?me->target_duration:1;
        while(first_download_iteration || live_streamming){
            {
                std::lock_guard<std::mutex> mlock(mutex_);
                if(flag_finish){
                    break;
                }
            }

            first_download_iteration = false;
            int i=0,current_file_count=0;
            
            for (; i < me->count&&me->media_segment[i].sequence_number <= lattest_sequence_number; i++);
            
            //Build downloading queue
            current_file_count = i;
            for (; i < me->count; i++) {
                //MSG_PRINT(me->media_segment[i].url); 
                segment_queue->push(std::make_shared<hls_media_segment>(me->media_segment[i]));
                lattest_sequence_number= me->media_segment[i].sequence_number;
            }


            MSG_PRINT("Update %d ts to queue\n",me->count - current_file_count);
            {
                std::unique_lock<std::mutex> mlock(mutex_);
                cond_.notify_one();
            }
            if(live_streamming){
                if(me->count - current_file_count < 1){    
                    
                    wait_second = wait_second*2;
                }else{
                    wait_second = me->target_duration;
                }
                MSG_PRINT("Sleep %d Seconds\n",wait_second);
                std::this_thread::sleep_for(std::chrono::seconds(wait_second));
                

                if (handle_hls_media_playlist(me,user_agent)) {
                    break;
                }
                MSG_PRINT("Reload m3u3 Playlist\n");
            }
        }
    });


    FILE *pFile = fopen(filename, "wb");
    int file_size=0;
    {
        std::unique_lock<std::mutex> mlock(mutex_);
        cond_.wait(mlock,[segment_queue]()->bool{return !(segment_queue->empty());});
    }
    while(!segment_queue->empty()){
        auto segment=segment_queue->pop();

        MSG_PRINT("Thread %d Downloading segment %d\n", 0, segment->sequence_number);
        auto buffer = std::make_shared<ByteBuffer>();

		// 下載TS視訊片段
        buffer->len = (int)get_data_from_url(segment->url.c_str(), NULL, &(buffer->data), BINARY,user_agent);
       
        if (me->encryption == true && me->encryptiontype == ENC_AES128) {
            decrypt_aes128(segment.get(), buffer.get());
        } else if (me->encryption == true && me->encryptiontype == ENC_AES_SAMPLE) {
            decrypt_sample_aes(segment.get(), buffer.get());
        }
		
		// 寫入本地檔案中
        fwrite(buffer->data, 1, buffer->len, pFile);
        fflush(pFile);
        free(buffer->data);
        file_size=file_size+buffer->len;
        MSG_PRINT("Totally Downloading Size: %d....Max size %d\n", file_size,max_file_size);
		
		// 如果下載的檔案的大小已經超過了最大的檔案大小，那麼表示伺服器上的PlayList可能已經更新了，本地應該及時更新
        if(max_file_size>0 && file_size >= max_file_size){
            std::lock_guard<std::mutex> mlock(mutex_);
            flag_finish = true; // 設定為true，那麼更新執行緒就可以繼續執行了
            MSG_PRINT("Reach Max Size %d! Finish.\n", max_file_size);
            break;
        }
        //delete segment;
    }


    fclose(pFile);
    update_playlist_thread->join();
    
    return 0;
}