iOS IdiotAVplayer实现视频分片缓存

文章目录

  • IdiotAVplayer 实现视频切片缓存
    • 一 iOS视频边下边播原理
    • 一 分片下载的实现
      • 1 分片下载的思路
      • 2 IdiotAVplayer 实现架构
    • 三 IdiotAVplayer 代码解析
      • IdiotPlayer
      • IdiotResourceLoader
      • IdiotDownLoader

IdiotAVplayer 实现视频切片缓存

一 iOS视频边下边播原理

初始化AVURLAsset 的时候,将资源链接中的http替换成其他字符串,并且将AVURLAsset的resourceLoader 设置代理对象,然后该代理对象实现AVAssetResourceLoaderDelegate 的代理方法

#pragma mark - AVAssetResourceLoaderDelegate
- (BOOL)resourceLoader:(AVAssetResourceLoader *)resourceLoader shouldWaitForLoadingOfRequestedResource:(AVAssetResourceLoadingRequest *)loadingRequest {
 
    return YES;
}

- (void)resourceLoader:(AVAssetResourceLoader *)resourceLoader didCancelLoadingRequest:(AVAssetResourceLoadingRequest *)loadingRequest {
}

在代理方法中实现资源的下载,保存, 并将下载好的资源塞给 loadingRequest, 实现视频的播放

一 分片下载的实现

简单的实现方案,就是将一个视频从头开始下载,或者从当前下载到的位置开始下载,然后下载到结束 这种方案对于短视频是可以的,因为短视频总共也没有多大,即使我们快进,从头下载开始到快进的地方也没有多少流量,用户体验影响不大,但是仍然浪费了中间的流量。
如果一个视频比较大,用户进行快进操作的话,从开头下载到用户快进的地方需要的时间很长,这时候,如果能根据用户快进的进度,根据用户的需要进行资源下载,那就是一个好的方案了。

1 分片下载的思路

步骤
1 首先根据链接获取本地资源
2 根据获取到的本地资源和视频请求request对比,计算需要新下载的资源 片段。
3 将本地的资源或者下载好的资源分片塞给请求对象request

2 IdiotAVplayer 实现架构

IdiotAVPlayer 负责实现视频播放功能

IdiotResourceLoader
负责实现
AVAssetResourceLoaderDelegate代理 方法,
负责将数据塞给AVAssetResourceLoadingRequest 请求,并管理AVAssetResourceLoadingRequest 请求,添加,移除,塞数据,快进的处理

IdiotDownLoader 负责 资源片段的获取,需要下载的片段的计算
NSURLSessionDelegate 代理方法的实现,并将下载好的数据传给IdiotResourceLoader, 还负责在读取本地数据的时候,将占用内存较大的视频资源分片读取到内存中传给 IdiotResourceLoader,避免造成因为资源较大而产生的内存撑爆问题

IdiotFileManager 负责管理下载的资源

三 IdiotAVplayer 代码解析

创建播放器,并设置resouceLoader代理

IdiotPlayer

    _resourceLoader = [[IdiotResourceLoader alloc] init];
    _resourceLoader.delegate = self;
    
    AVURLAsset * playerAsset = [AVURLAsset URLAssetWithURL:[_currentUrl idiotSchemeURL] options:nil];
    [playerAsset.resourceLoader setDelegate:_resourceLoader queue:_queue];
    
    _playerItem = [AVPlayerItem playerItemWithAsset:playerAsset];

IdiotResourceLoader

- (BOOL)resourceLoader:(AVAssetResourceLoader *)resourceLoader shouldWaitForLoadingOfRequestedResource:(AVAssetResourceLoadingRequest *)loadingRequest {
        [self addLoadingRequest:loadingRequest];
    
    DLogDebug(@"loadingRequest == %@",loadingRequest)
    
    return YES;
}

- (void)resourceLoader:(AVAssetResourceLoader *)resourceLoader didCancelLoadingRequest:(AVAssetResourceLoadingRequest *)loadingRequest {
    [self removeLoadingRequest:loadingRequest];
}

- (void)removeLoadingRequest:(AVAssetResourceLoadingRequest *)loadingRequest {
    
    dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
    NSArray * temptaskList = [NSArray arrayWithArray:self.taskList];
    dispatch_semaphore_signal(semaphore);
    
    IdiotResourceTask * deleteTask = nil;
    
    for (IdiotResourceTask * task in temptaskList) {
        if ([task.loadingRequest isEqual:loadingRequest]) {
            deleteTask = task;
            break;
        }
    }
    
    if (deleteTask) {
        dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
        [self.taskList removeObject:deleteTask];
        dispatch_semaphore_signal(semaphore);
    }
    
}

- (void)addLoadingRequest:(AVAssetResourceLoadingRequest *)loadingRequest {
    
    if (self.currentResource) {
       
        if (loadingRequest.dataRequest.requestedOffset >= self.currentResource.requestOffset &&
            loadingRequest.dataRequest.requestedOffset <= self.currentResource.requestOffset + self.currentResource.cacheLength) {
            IdiotResourceTask * task = [[IdiotResourceTask alloc] init];
            task.loadingRequest = loadingRequest;
            task.resource = self.currentResource;
            dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
            [self.taskList addObject:task];
            dispatch_semaphore_signal(semaphore);
            [self processRequestList];
            
        }else{
            
            if (self.seek) {
                [self newTaskWithLoadingRequest:loadingRequest];
            }else{
                
                IdiotResourceTask * task = [[IdiotResourceTask alloc] init];
                task.loadingRequest = loadingRequest;
                task.resource = self.currentResource;
                NSLog(@"哈哈哈哈哈啊哈哈这里这里这里添加22222 %lld  %lld %p\n", loadingRequest.dataRequest.requestedOffset, loadingRequest.dataRequest.currentOffset, task);

                dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
                [self.taskList addObject:task];
                dispatch_semaphore_signal(semaphore);
            }
            
        }
        
    }else {
        [self newTaskWithLoadingRequest:loadingRequest];
    }
}

- (void)newTaskWithLoadingRequest:(AVAssetResourceLoadingRequest *)loadingRequest {
    
    long long fileLength = 0;
    
    if (self.currentResource) {
        fileLength = self.currentResource.fileLength;
        self.currentResource.cancel = YES;
    }
    
    IdiotResource * resource = [[IdiotResource alloc] init];
    resource.requestURL = loadingRequest.request.URL;
    resource.requestOffset = loadingRequest.dataRequest.requestedOffset;
    resource.resourceType = IdiotResourceTypeTask;
    if (fileLength > 0) {
        resource.fileLength = fileLength;
    }
    
    IdiotResourceTask * task = [[IdiotResourceTask alloc] init];
    task.loadingRequest = loadingRequest;
    task.resource = resource;
    
    self.currentResource = resource;
    
    dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
    [self.taskList addObject:task];
    dispatch_semaphore_signal(semaphore);
    printf("哈哈哈这里事创建的这里事创建的%lld  %lld %lld  %p %p\n", resource.requestOffset, loadingRequest.dataRequest.requestedOffset, loadingRequest.dataRequest.currentOffset, loadingRequest, task);
    [IdiotDownLoader share].delegate = self;
    [[IdiotDownLoader share] start:self.currentResource];
    
    self.seek = NO;
}

- (void)stopResourceLoader{
    [[IdiotDownLoader share] cancel];
}

- (void)processRequestList {
    @synchronized (self) {
        
        dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
        NSArray * temptaskList = [NSArray arrayWithArray:self.taskList];
        dispatch_semaphore_signal(semaphore);
        
        for (IdiotResourceTask * task in temptaskList) {

            NSInvocationOperation * invoke = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(finishLoadingWithLoadingRequest:) object:task];
            
            [_playQueue addOperation:invoke];
            
        }
        
    }
}

- (void)finishLoadingWithLoadingRequest:(IdiotResourceTask *)task {
    
    //填充信息
    task.loadingRequest.contentInformationRequest.contentType = @"video/mp4";
    task.loadingRequest.contentInformationRequest.byteRangeAccessSupported = YES;
    task.loadingRequest.contentInformationRequest.contentLength = task.resource.fileLength;
    
    if (task.resource.fileLength <= 0) {
        DLogDebug(@"requestTask.fileLength <= 0");
    }
    
    //读文件,填充数据
    long long cacheLength = task.resource.cacheLength;
    long long requestedOffset = task.loadingRequest.dataRequest.requestedOffset;
    if (task.loadingRequest.dataRequest.currentOffset != 0) {
        requestedOffset = task.loadingRequest.dataRequest.currentOffset;
    }
    printf("哈哈哈1111执行执行执行%lld点 %lld 一 %lld %p  %p\n", task.loadingRequest.dataRequest.requestedOffset,task.loadingRequest.dataRequest.currentOffset, task.resource.requestOffset, task.loadingRequest, task);
    printf("哈哈哈数量数量%ld\n", self.taskList.count);
    for (IdiotResourceTask *task1 in self.taskList) {
        printf("哈哈哈啦啊啦这里这里数组里的%p %lld\n",task1, task.resource.requestOffset);
    }

    if (requestedOffset < task.resource.requestOffset) {
        printf("哈哈哈1111返回%lld点 %lld 一 %lld %p  %p\n", task.loadingRequest.dataRequest.requestedOffset,task.loadingRequest.dataRequest.currentOffset, task.resource.requestOffset, task.loadingRequest, task);
        return;
    }
    
    long long paddingOffset = requestedOffset - task.resource.requestOffset;
    
    long long canReadLength = cacheLength - paddingOffset;
    
    printf("哈哈哈能获取到的能获取到的%lld \n", canReadLength);
    
    if (canReadLength <= 0) {
        printf("哈哈哈返回222222 %lld\n", canReadLength);
        return;
    }
    
    long long respondLength = MIN(canReadLength, task.loadingRequest.dataRequest.requestedLength);
    
    NSFileHandle * handle = [IdiotFileManager fileHandleForReadingAtPath:task.resource.cachePath];
    
    [handle seekToFileOffset:paddingOffset];
    
    [task.loadingRequest.dataRequest respondWithData:[handle readDataOfLength:[[NSNumber numberWithLongLong:respondLength] unsignedIntegerValue]]];
    printf("哈哈哈匹配到匹配到%lld \n",respondLength);

    [handle closeFile];
    
    //如果完全响应了所需要的数据,则完成
    long long nowendOffset = requestedOffset + canReadLength;
    long long reqEndOffset = task.loadingRequest.dataRequest.requestedOffset + task.loadingRequest.dataRequest.requestedLength;
    printf("哈哈哈差别差别%lld\n",reqEndOffset - nowendOffset);
    if (nowendOffset >= reqEndOffset) {
        [task.loadingRequest finishLoading];
        printf("哈哈哈移除移除移除%lld %lld\n", nowendOffset, reqEndOffset);
        [self removeLoadingRequest:task.loadingRequest];
        
        return;
    }
    
}

#pragma mark - DownLoaderDataDelegate
- (void)didReceiveData:(IdiotDownLoader *__weak)downLoader{
    
    [self processRequestList];
    
    if (self.delegate&&[self.delegate respondsToSelector:@selector(didCacheProgressChange:)]) {
        __weak typeof(self) weakself = self;
        dispatch_async(dispatch_get_main_queue(), ^{
            __strong typeof(weakself) strongself = weakself;
            
            NSMutableArray * caches = [downLoader.resources mutableCopy];
            
            [caches addObject:self.currentResource];
            
            [strongself.delegate didCacheProgressChange:caches];
        });
    }
    
}

下面单独介绍各个方法的实现

    
    if (self.currentResource) {
       
        if (loadingRequest.dataRequest.requestedOffset >= self.currentResource.requestOffset &&
            loadingRequest.dataRequest.requestedOffset <= self.currentResource.requestOffset + self.currentResource.cacheLength) {
            IdiotResourceTask * task = [[IdiotResourceTask alloc] init];
            task.loadingRequest = loadingRequest;
            task.resource = self.currentResource;
            dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
            [self.taskList addObject:task];
            dispatch_semaphore_signal(semaphore);
            [self processRequestList];
            
        }else{
            
            if (self.seek) {
                [self newTaskWithLoadingRequest:loadingRequest];
            }else{
                
                IdiotResourceTask * task = [[IdiotResourceTask alloc] init];
                task.loadingRequest = loadingRequest;
                task.resource = self.currentResource;
                dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
                [self.taskList addObject:task];
                dispatch_semaphore_signal(semaphore);
            }
            
        }
        
    }else {
        [self newTaskWithLoadingRequest:loadingRequest];
    }
}

上面方法中,的判断条件 self.currentResource 说明执行过newTaskWithLoadingRequest 方法了,因为在该方法中设置了self.currentResource,说明就不是第一次执行addLoadingRequest 添加request了,loadingRequest.dataRequest.requestedOffset >= self.currentResource.requestOffset &&
loadingRequest.dataRequest.requestedOffset <= self.currentResource.requestOffset + self.currentResource.cacheLength 该判断条件说明
新请求的offset 是大于当前的offset, 但是小于当前的offset + cachelength ,说明
当前的的本地资源是有一部分是可以塞给当前的 request的 ,所以在创建了新的任务task的同时,还执行了 [self processRequestList];
方法。下面的 else中 if (self.seek) 说明当前的request是因为用户拖拽进度条触发的,所以要重新创建一个source ,因为一个拖拽就会引起一个不连续的下载片段,而在IdiotAvplayer的设计中,每一个资源片段都要有一个resouce,
所以要执行newTaskWithLoadingRequest 方法
else说明不是拖拽的,则直接添加新的任务即可,等到新的下载好的资源到来,就会去塞给新添加的请求,而新的下载是不会停止的,直到到达资源的最后。


- (void)finishLoadingWithLoadingRequest:(IdiotResourceTask *)task {
    
    //填充信息
    task.loadingRequest.contentInformationRequest.contentType = @"video/mp4";
    task.loadingRequest.contentInformationRequest.byteRangeAccessSupported = YES;
    task.loadingRequest.contentInformationRequest.contentLength = task.resource.fileLength;
    
    if (task.resource.fileLength <= 0) {
        DLogDebug(@"requestTask.fileLength <= 0");
    }
    
    //读文件,填充数据
    long long cacheLength = task.resource.cacheLength;
    long long requestedOffset = task.loadingRequest.dataRequest.requestedOffset;
    if (task.loadingRequest.dataRequest.currentOffset != 0) {
        requestedOffset = task.loadingRequest.dataRequest.currentOffset;
    }
 
    if (requestedOffset < task.resource.requestOffset) {
  /*
  task.resource 是第一次播放或者拖拽才会创建的对象,其 requestOffset就是对应的那次请求的offset,
  这里的判断条件 requestedOffset < task.resource.requestOffset 说明 该request是 创建 resouce 之前的request
  ,那么该resouce 对应的资源中满足该request,所以就返回
    */  
        return;
    }
    
    long long paddingOffset = requestedOffset - task.resource.requestOffset;
    
    long long canReadLength = cacheLength - paddingOffset;
        
    if (canReadLength <= 0) {
       如果该resouce offset+ resouce的资源长度,仍然小与request 的offset,
       说明该资源完全在request的前面,无法满足该request,返回
        return;
    }
    
    long long respondLength = MIN(canReadLength, task.loadingRequest.dataRequest.requestedLength);
    
    NSFileHandle * handle = [IdiotFileManager fileHandleForReadingAtPath:task.resource.cachePath];
    
    [handle seekToFileOffset:paddingOffset];
    
    [task.loadingRequest.dataRequest respondWithData:[handle readDataOfLength:[[NSNumber numberWithLongLong:respondLength] unsignedIntegerValue]]];

    [handle closeFile];
    
    //如果完全响应了所需要的数据,则完成
    long long nowendOffset = requestedOffset + canReadLength;
    long long reqEndOffset = task.loadingRequest.dataRequest.requestedOffset + task.loadingRequest.dataRequest.requestedLength;
    if (nowendOffset >= reqEndOffset) {
        [task.loadingRequest finishLoading];
        [self removeLoadingRequest:task.loadingRequest];
        
        return;
    }
    
}

如下图,分片缓存的资源在沙盒中的保存形式,是根据offset 分别保存的
iOS IdiotAVplayer实现视频分片缓存_第1张图片

IdiotDownLoader

- (void)start:(IdiotResource *)task {
    
    if (self.currentDataTask) {
        [self.currentDataTask cancel];
    }
    
    [self.taskDic setObject:task forKey:[NSString stringWithFormat:@"%zd",task.requestOffset]];
    
    //获取本地资源
    BOOL refresh = NO;
    
    while (!self.writing&&!refresh) {
        self.resources = [IdiotFileManager getResourceWithUrl:task.requestURL];
        refresh = YES;
    }
    
    IdiotResource * resource = nil;//找出对应的资源
    
    if (!self.resources.count) {//本地无资源
        resource = [[IdiotResource alloc] init];
        resource.requestURL = task.requestURL;
        resource.requestOffset = task.requestOffset;
        resource.fileLength = task.fileLength;
        resource.cachePath = task.cachePath;
        resource.cacheLength = 0;
        resource.resourceType = IdiotResourceTypeNet;//网络资源
        [self.resources addObject:resource];
    }else{//本地有资源
        
        for (IdiotResource * obj in self.resources) {
            if (task.requestOffset >= obj.requestOffset&&
                task.requestOffset < obj.requestOffset+obj.cacheLength) {
				/*
				该判断条件说明当前任务offset比获取的本地分片
				资源offset大,比本地分片资源offset+cachelength小,在
				本地资源中间,有重合的地方
				*/
                resource = obj;
                break;
            }
        }
        
        if (task.requestOffset > resource.requestOffset&&
            resource.resourceType == IdiotResourceTypeNet) {
            /*
            该resouce 是从上面的判断条件中获取的
				该判断说明当前任务比获取到的本地resouce offset大,并且是网路请求资源,说明
				本地没有资源,需要重新下载,这里新建一个IdiotResource,并且设置offset=task.offset
				就是为了从当前任务的offset开始下载,否则会中本得resouce 的offset开始下载,
				这样就会导致下载的比我们需要的多,并且用户会有一个卡住的体验,因为下载的不是用户
				需要的offset,这里这样写,保证下载的offset就是用户需要的,并且避免流量浪费  
			*/
            long long adjustCacheLength = task.requestOffset - resource.requestOffset;
            
            IdiotResource * net = [[IdiotResource alloc] init];
            net.requestURL = task.requestURL;
            net.requestOffset = task.requestOffset;
            net.fileLength = task.fileLength;
            net.cachePath = task.cachePath;
            net.cacheLength = resource.cacheLength - adjustCacheLength;
            net.resourceType = IdiotResourceTypeNet;//网络资源
            
            resource.cacheLength = adjustCacheLength;
            
            NSInteger index = [self.resources indexOfObject:resource]+1;
            
            [self.resources insertObject:net atIndex:index];
            
            resource = net;
        }
        
    }
    
    self.currentResource = resource;
    
    [self fetchDataWith:task Resource:self.currentResource];
    
}


- (void)fetchFromLocal:(IdiotResource *)sliceRequest withResource:(IdiotResource *)resource{
    
    if (sliceRequest.requestOffset == resource.requestOffset) {
        
        sliceRequest.cachePath = resource.cachePath;
        sliceRequest.fileLength = resource.fileLength;
        sliceRequest.cacheLength = resource.cacheLength;
        
        //直接开始下一个资源获取
        if (self.delegate && [self.delegate respondsToSelector:@selector(didReceiveData:)]) {
            [self.delegate didReceiveData:self];
        }
        
        [self willNextResource:sliceRequest];
        
        return;
    }
    
    NSFileHandle * readHandle = [IdiotFileManager fileHandleForReadingAtPath:resource.cachePath];
    
    unsigned long long seekOffset = sliceRequest.requestOffset < resource.requestOffset?0:sliceRequest.requestOffset-resource.requestOffset;
    
    [readHandle seekToFileOffset:seekOffset];
    
    //文件过大可分次读取
    long long canReadLength = resource.cacheLength-seekOffset;
    NSUInteger bufferLength = 5242880; //长度大于5M分次返回数据
    /*
    如果本地资源比较大,就分片塞数据,如果一下将整个资源读取到内存中,就会造成
    内存撑爆,导致严重的卡顿
    */
    while (canReadLength >= bufferLength) {//长度大于1M分次返回数据
        
        canReadLength -= bufferLength;
        
        NSData * responseData = [readHandle readDataOfLength:bufferLength];
        
        [self didReceiveLocalData:responseData requestTask:sliceRequest complete:canReadLength==0?YES:NO];
        
    }
    
    if (canReadLength != 0) {
        NSData * responseData = [readHandle readDataOfLength:[[NSNumber numberWithLongLong:canReadLength] unsignedIntegerValue]];
        [readHandle closeFile];
        
        [self didReceiveLocalData:responseData requestTask:sliceRequest complete:YES];
    }else{
        [readHandle closeFile];
    }
    
}

你可能感兴趣的:(音视频,ios,音视频,缓存)