iOS ijkplayer 播放器 消息循环 详解

最新推荐文章于 2022-08-11 09:42:03 发布
最新推荐文章于 2022-08-11 09:42:03 发布
阅读量3.6k 收藏 2
点赞数
分类专栏： iOS_音视频
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jeffasd/article/details/72820625
版权

iOS ijkplayer 消息循环

_mediaPlayer = ijkmp_ios_create(media_player_msg_loop);//开始消息循环
int media_player_msg_loop(void* arg)
{
    @autoreleasepool {
        IjkMediaPlayer *mp = (IjkMediaPlayer*)arg;
        __weak IJKFFMoviePlayerController *ffpController = ffplayerRetain(ijkmp_set_weak_thiz(mp, NULL));
        while (ffpController) {
            @autoreleasepool {
                IJKFFMoviePlayerMessage *msg = [ffpController obtainMessage];
                if (!msg)
                    break;

                int retval = ijkmp_get_msg(mp, &msg->_msg, 1);
                if (retval < 0)
                    break;

                // block-get should never return 0
                assert(retval > 0);
		//此处发送消息
                [ffpController performSelectorOnMainThread:@selector(postEvent:) withObject:msg waitUntilDone:NO];
            }
        }

        // retained in prepare_async, before SDL_CreateThreadEx
        ijkmp_dec_ref_p(&mp);
        return 0;
    }
}
//消息循环处理函数

在消息循环处理函数中有两个关键地方
ijkmp_get_msg(mp, &msg->_msg, 1);//获取到消息并对消息做初步处理
[ffpController performSelectorOnMainThread:@selector(postEvent:) withObject:msg waitUntilDone:NO];//将消息通过postEvent函数发出并做消息处理

//获取消息并对消息做初步处理
/* need to call msg_free_res for freeing the resouce obtained in msg */
int ijkmp_get_msg(IjkMediaPlayer *mp, AVMessage *msg, int block)
{
    assert(mp);
    while (1) {
        int continue_wait_next_msg = 0;
        int retval = msg_queue_get(&mp->ffplayer->msg_queue, msg, block);
        if (retval <= 0)
            return retval;

        switch (msg->what) {
        case FFP_MSG_PREPARED:
            MPTRACE("ijkmp_get_msg: FFP_MSG_PREPARED\n");
            pthread_mutex_lock(&mp->mutex);
            if (mp->mp_state == MP_STATE_ASYNC_PREPARING) {
                ijkmp_change_state_l(mp, MP_STATE_PREPARED);
            } else {
                // FIXME: 1: onError() ?
                av_log(mp->ffplayer, AV_LOG_DEBUG, "FFP_MSG_PREPARED: expecting mp_state==MP_STATE_ASYNC_PREPARING\n");
            }
            if (ffp_is_paused_l(mp->ffplayer)) {
                ijkmp_change_state_l(mp, MP_STATE_PAUSED);
            }
            pthread_mutex_unlock(&mp->mutex);
            break;

        case FFP_MSG_COMPLETED:
            MPTRACE("ijkmp_get_msg: FFP_MSG_COMPLETED\n");

            pthread_mutex_lock(&mp->mutex);
            mp->restart = 1;
            mp->restart_from_beginning = 1;
            ijkmp_change_state_l(mp, MP_STATE_COMPLETED);
            pthread_mutex_unlock(&mp->mutex);
            break;

        case FFP_MSG_SEEK_COMPLETE:
            MPTRACE("ijkmp_get_msg: FFP_MSG_SEEK_COMPLETE\n");

            pthread_mutex_lock(&mp->mutex);
            mp->seek_req = 0;
            mp->seek_msec = 0;
            pthread_mutex_unlock(&mp->mutex);
            break;

        case FFP_REQ_START:
            MPTRACE("ijkmp_get_msg: FFP_REQ_START\n");
            continue_wait_next_msg = 1;
            pthread_mutex_lock(&mp->mutex);
            if (0 == ikjmp_chkst_start_l(mp->mp_state)) {
                // FIXME: 8 check seekable
                if (mp->restart) {
                    if (mp->restart_from_beginning) {
                        av_log(mp->ffplayer, AV_LOG_DEBUG, "ijkmp_get_msg: FFP_REQ_START: restart from beginning\n");
                        retval = ffp_start_from_l(mp->ffplayer, 0);
                        if (retval == 0)
                            ijkmp_change_state_l(mp, MP_STATE_STARTED);
                    } else {
                        av_log(mp->ffplayer, AV_LOG_DEBUG, "ijkmp_get_msg: FFP_REQ_START: restart from seek pos\n");
                        retval = ffp_start_l(mp->ffplayer);
                        if (retval == 0)
                            ijkmp_change_state_l(mp, MP_STATE_STARTED);
                    }
                    mp->restart = 0;
                    mp->restart_from_beginning = 0;
                } else {
                    av_log(mp->ffplayer, AV_LOG_DEBUG, "ijkmp_get_msg: FFP_REQ_START: start on fly\n");
                    retval = ffp_start_l(mp->ffplayer);
                    if (retval == 0)
                        ijkmp_change_state_l(mp, MP_STATE_STARTED);
                }
            }
            pthread_mutex_unlock(&mp->mutex);
            break;

        case FFP_REQ_PAUSE:
            MPTRACE("ijkmp_get_msg: FFP_REQ_PAUSE\n");
            continue_wait_next_msg = 1;
            pthread_mutex_lock(&mp->mutex);
            if (0 == ikjmp_chkst_pause_l(mp->mp_state)) {
                int pause_ret = ffp_pause_l(mp->ffplayer);
                if (pause_ret == 0)
                    ijkmp_change_state_l(mp, MP_STATE_PAUSED);
            }
            pthread_mutex_unlock(&mp->mutex);
            break;

        case FFP_REQ_SEEK:
            MPTRACE("ijkmp_get_msg: FFP_REQ_SEEK\n");
            continue_wait_next_msg = 1;

            pthread_mutex_lock(&mp->mutex);
            if (0 == ikjmp_chkst_seek_l(mp->mp_state)) {
                mp->restart_from_beginning = 0;
                if (0 == ffp_seek_to_l(mp->ffplayer, msg->arg1)) {
                    av_log(mp->ffplayer, AV_LOG_DEBUG, "ijkmp_get_msg: FFP_REQ_SEEK: seek to %d\n", (int)msg->arg1);
                }
            }
            pthread_mutex_unlock(&mp->mutex);
            break;
        }
        if (continue_wait_next_msg) {
            msg_free_res(msg);
            continue;
        }

        return retval;
    }

    return -1;
}

//通过此函数将消息发出并对消息做出处理
- (void)postEvent: (IJKFFMoviePlayerMessage *)msg
{
    if (!msg)
        return;

    AVMessage *avmsg = &msg->_msg;
    switch (avmsg->what) {
        case FFP_MSG_FLUSH:
            break;
        case FFP_MSG_ERROR: {
            NSLog(@"FFP_MSG_ERROR: %d\n", avmsg->arg1);

            [self setScreenOn:NO];

            [[NSNotificationCenter defaultCenter]
             postNotificationName:IJKMPMoviePlayerPlaybackStateDidChangeNotification
             object:self];

            [[NSNotificationCenter defaultCenter]
                postNotificationName:IJKMPMoviePlayerPlaybackDidFinishNotification
                object:self
                userInfo:@{
                    IJKMPMoviePlayerPlaybackDidFinishReasonUserInfoKey: @(IJKMPMovieFinishReasonPlaybackError),
                    @"error": @(avmsg->arg1)}];
            break;
        }
        case FFP_MSG_PREPARED: {
            NSLog(@"FFP_MSG_PREPARED:\n");

            _monitor.prepareDuration = (int64_t)SDL_GetTickHR() - _monitor.prepareStartTick;
            int64_t vdec = ijkmp_get_property_int64(_mediaPlayer, FFP_PROP_INT64_VIDEO_DECODER, FFP_PROPV_DECODER_UNKNOWN);
            switch (vdec) {
                case FFP_PROPV_DECODER_VIDEOTOOLBOX:
                    _monitor.vdecoder = @"VideoToolbox";
                    break;
                case FFP_PROPV_DECODER_AVCODEC:
                    _monitor.vdecoder = [NSString stringWithFormat:@"avcodec %d.%d.%d",
                                         LIBAVCODEC_VERSION_MAJOR,
                                         LIBAVCODEC_VERSION_MINOR,
                                         LIBAVCODEC_VERSION_MICRO];
                    break;
                default:
                    _monitor.vdecoder = @"Unknown";
                    break;
            }

            IjkMediaMeta *rawMeta = ijkmp_get_meta_l(_mediaPlayer);
            if (rawMeta) {
                ijkmeta_lock(rawMeta);

                NSMutableDictionary *newMediaMeta = [[NSMutableDictionary alloc] init];

                fillMetaInternal(newMediaMeta, rawMeta, IJKM_KEY_FORMAT, nil);
                fillMetaInternal(newMediaMeta, rawMeta, IJKM_KEY_DURATION_US, nil);
                fillMetaInternal(newMediaMeta, rawMeta, IJKM_KEY_START_US, nil);
                fillMetaInternal(newMediaMeta, rawMeta, IJKM_KEY_BITRATE, nil);

                fillMetaInternal(newMediaMeta, rawMeta, IJKM_KEY_VIDEO_STREAM, nil);
                fillMetaInternal(newMediaMeta, rawMeta, IJKM_KEY_AUDIO_STREAM, nil);

                int64_t video_stream = ijkmeta_get_int64_l(rawMeta, IJKM_KEY_VIDEO_STREAM, -1);
                int64_t audio_stream = ijkmeta_get_int64_l(rawMeta, IJKM_KEY_AUDIO_STREAM, -1);

                NSMutableArray *streams = [[NSMutableArray alloc] init];

                size_t count = ijkmeta_get_children_count_l(rawMeta);
                for(size_t i = 0; i < count; ++i) {
                    IjkMediaMeta *streamRawMeta = ijkmeta_get_child_l(rawMeta, i);
                    NSMutableDictionary *streamMeta = [[NSMutableDictionary alloc] init];

                    if (streamRawMeta) {
                        fillMetaInternal(streamMeta, streamRawMeta, IJKM_KEY_TYPE, k_IJKM_VAL_TYPE__UNKNOWN);
                        const char *type = ijkmeta_get_string_l(streamRawMeta, IJKM_KEY_TYPE);
                        if (type) {
                            fillMetaInternal(streamMeta, streamRawMeta, IJKM_KEY_CODEC_NAME, nil);
                            fillMetaInternal(streamMeta, streamRawMeta, IJKM_KEY_CODEC_PROFILE, nil);
                            fillMetaInternal(streamMeta, streamRawMeta, IJKM_KEY_CODEC_LONG_NAME, nil);
                            fillMetaInternal(streamMeta, streamRawMeta, IJKM_KEY_BITRATE, nil);

                            if (0 == strcmp(type, IJKM_VAL_TYPE__VIDEO)) {
                                fillMetaInternal(streamMeta, streamRawMeta, IJKM_KEY_WIDTH, nil);
                                fillMetaInternal(streamMeta, streamRawMeta, IJKM_KEY_HEIGHT, nil);
                                fillMetaInternal(streamMeta, streamRawMeta, IJKM_KEY_FPS_NUM, nil);
                                fillMetaInternal(streamMeta, streamRawMeta, IJKM_KEY_FPS_DEN, nil);
                                fillMetaInternal(streamMeta, streamRawMeta, IJKM_KEY_TBR_NUM, nil);
                                fillMetaInternal(streamMeta, streamRawMeta, IJKM_KEY_TBR_DEN, nil);
                                fillMetaInternal(streamMeta, streamRawMeta, IJKM_KEY_SAR_NUM, nil);
                                fillMetaInternal(streamMeta, streamRawMeta, IJKM_KEY_SAR_DEN, nil);

                                if (video_stream == i) {
                                    _monitor.videoMeta = streamMeta;

                                    int64_t fps_num = ijkmeta_get_int64_l(streamRawMeta, IJKM_KEY_FPS_NUM, 0);
                                    int64_t fps_den = ijkmeta_get_int64_l(streamRawMeta, IJKM_KEY_FPS_DEN, 0);
                                    if (fps_num > 0 && fps_den > 0) {
                                        _fpsInMeta = ((CGFloat)(fps_num)) / fps_den;
                                        NSLog(@"fps in meta %f\n", _fpsInMeta);
                                    }
                                }

                            } else if (0 == strcmp(type, IJKM_VAL_TYPE__AUDIO)) {
                                fillMetaInternal(streamMeta, streamRawMeta, IJKM_KEY_SAMPLE_RATE, nil);
                                fillMetaInternal(streamMeta, streamRawMeta, IJKM_KEY_CHANNEL_LAYOUT, nil);

                                if (audio_stream == i) {
                                    _monitor.audioMeta = streamMeta;
                                }
                            }
                        }
                    }

                    [streams addObject:streamMeta];
                }

                [newMediaMeta setObject:streams forKey:kk_IJKM_KEY_STREAMS];

                ijkmeta_unlock(rawMeta);
                _monitor.mediaMeta = newMediaMeta;
            }
            ijkmp_set_playback_rate(_mediaPlayer, [self playbackRate]);
            ijkmp_set_playback_volume(_mediaPlayer, [self playbackVolume]);

            [self startHudTimer];
            _isPreparedToPlay = YES;

            [[NSNotificationCenter defaultCenter] postNotificationName:IJKMPMediaPlaybackIsPreparedToPlayDidChangeNotification object:self];
            _loadState = IJKMPMovieLoadStatePlayable | IJKMPMovieLoadStatePlaythroughOK;

            [[NSNotificationCenter defaultCenter]
             postNotificationName:IJKMPMoviePlayerLoadStateDidChangeNotification
             object:self];

            break;
        }
        case FFP_MSG_COMPLETED: {

            [self setScreenOn:NO];

            [[NSNotificationCenter defaultCenter]
             postNotificationName:IJKMPMoviePlayerPlaybackStateDidChangeNotification
             object:self];

            [[NSNotificationCenter defaultCenter]
             postNotificationName:IJKMPMoviePlayerPlaybackDidFinishNotification
             object:self
             userInfo:@{IJKMPMoviePlayerPlaybackDidFinishReasonUserInfoKey: @(IJKMPMovieFinishReasonPlaybackEnded)}];
            break;
        }
        case FFP_MSG_VIDEO_SIZE_CHANGED:
            NSLog(@"FFP_MSG_VIDEO_SIZE_CHANGED: %d, %d\n", avmsg->arg1, avmsg->arg2);
            if (avmsg->arg1 > 0)
                _videoWidth = avmsg->arg1;
            if (avmsg->arg2 > 0)
                _videoHeight = avmsg->arg2;
            [self changeNaturalSize];
            break;
        case FFP_MSG_SAR_CHANGED:
            NSLog(@"FFP_MSG_SAR_CHANGED: %d, %d\n", avmsg->arg1, avmsg->arg2);
            if (avmsg->arg1 > 0)
                _sampleAspectRatioNumerator = avmsg->arg1;
            if (avmsg->arg2 > 0)
                _sampleAspectRatioDenominator = avmsg->arg2;
            [self changeNaturalSize];
            break;
        case FFP_MSG_BUFFERING_START: {
            NSLog(@"FFP_MSG_BUFFERING_START:\n");

            _monitor.lastPrerollStartTick = (int64_t)SDL_GetTickHR();

            _loadState = IJKMPMovieLoadStateStalled;

            [[NSNotificationCenter defaultCenter]
             postNotificationName:IJKMPMoviePlayerLoadStateDidChangeNotification
             object:self];
            break;
        }
        case FFP_MSG_BUFFERING_END: {
            NSLog(@"FFP_MSG_BUFFERING_END:\n");

            _monitor.lastPrerollDuration = (int64_t)SDL_GetTickHR() - _monitor.lastPrerollStartTick;

            _loadState = IJKMPMovieLoadStatePlayable | IJKMPMovieLoadStatePlaythroughOK;

            [[NSNotificationCenter defaultCenter]
             postNotificationName:IJKMPMoviePlayerLoadStateDidChangeNotification
             object:self];
            [[NSNotificationCenter defaultCenter]
             postNotificationName:IJKMPMoviePlayerPlaybackStateDidChangeNotification
             object:self];
            break;
        }
        case FFP_MSG_BUFFERING_UPDATE:
            _bufferingPosition = avmsg->arg1;
            _bufferingProgress = avmsg->arg2;
            // NSLog(@"FFP_MSG_BUFFERING_UPDATE: %d, %%%d\n", _bufferingPosition, _bufferingProgress);
            break;
        case FFP_MSG_BUFFERING_BYTES_UPDATE:
            // NSLog(@"FFP_MSG_BUFFERING_BYTES_UPDATE: %d\n", avmsg->arg1);
            break;
        case FFP_MSG_BUFFERING_TIME_UPDATE:
            _bufferingTime       = avmsg->arg1;
            // NSLog(@"FFP_MSG_BUFFERING_TIME_UPDATE: %d\n", avmsg->arg1);
            break;
        case FFP_MSG_PLAYBACK_STATE_CHANGED:
            [[NSNotificationCenter defaultCenter]
             postNotificationName:IJKMPMoviePlayerPlaybackStateDidChangeNotification
             object:self];
            break;
        case FFP_MSG_SEEK_COMPLETE: {
            NSLog(@"FFP_MSG_SEEK_COMPLETE:\n");
            [[NSNotificationCenter defaultCenter]
             postNotificationName:IJKMPMoviePlayerDidSeekCompleteNotification
             object:self
             userInfo:@{IJKMPMoviePlayerDidSeekCompleteTargetKey: @(avmsg->arg1),
                        IJKMPMoviePlayerDidSeekCompleteErrorKey: @(avmsg->arg2)}];
            _seeking = NO;
            break;
        }
        case FFP_MSG_VIDEO_DECODER_OPEN: {
            _isVideoToolboxOpen = avmsg->arg1;
            NSLog(@"FFP_MSG_VIDEO_DECODER_OPEN: %@\n", _isVideoToolboxOpen ? @"true" : @"false");
            [[NSNotificationCenter defaultCenter]
             postNotificationName:IJKMPMoviePlayerVideoDecoderOpenNotification
             object:self];
            break;
        }
        case FFP_MSG_VIDEO_RENDERING_START: {
            NSLog(@"FFP_MSG_VIDEO_RENDERING_START:\n");
            _monitor.firstVideoFrameLatency = (int64_t)SDL_GetTickHR() - _monitor.prepareStartTick;
            [[NSNotificationCenter defaultCenter]
             postNotificationName:IJKMPMoviePlayerFirstVideoFrameRenderedNotification
             object:self];
            break;
        }
        case FFP_MSG_AUDIO_RENDERING_START: {
            NSLog(@"FFP_MSG_AUDIO_RENDERING_START:\n");
            [[NSNotificationCenter defaultCenter]
             postNotificationName:IJKMPMoviePlayerFirstAudioFrameRenderedNotification
             object:self];
            break;
        }
        case FFP_MSG_ACCURATE_SEEK_COMPLETE: {
            NSLog(@"FFP_MSG_ACCURATE_SEEK_COMPLETE:\n");
            [[NSNotificationCenter defaultCenter]
             postNotificationName:IJKMPMoviePlayerAccurateSeekCompleteNotification
             object:self
             userInfo:@{IJKMPMoviePlayerDidAccurateSeekCompleteCurPos: @(avmsg->arg1)}];
            break;
        }
        default:
            // NSLog(@"unknown FFP_MSG_xxx(%d)\n", avmsg->what);
            break;
    }

    [_msgPool recycle:msg];
}

jeffasd
关注
专栏目录
iOS 开源播放器ijkplayer播放视频设置缓存
川流不息
04-27 3108
最近接受一个视频播放的项目 发现一个问题视频在拖动的时候 需要等很久才能播放 看了下代码使用的是B站开源的ijkplayer 查了下资料很多人说没有ijkplayer每次都seek时都重新链接获取数据导致耗时很长。查了下资料发现很少涉及到播放器缓存这块，更有人说ijkplayer不支持缓存。 于是下了ijkplayer的源码 编译一下 编译过程不说了 很方便的 代码里简单搜索下cache 搜到了cache的相关信息说明ijkplayer还是支持的。又查了下代码和资料完成这功能seek时能够做到秒开。 具
基于ijkmediaplayer的播放器
04-21
对播放界面进行了拓展
ijkmediaplayer-ios:IOS版本编译好的ijkmediaplayer库
06-08
ijkmediaplayer-ios IOS版本编译好的ijkmediaplayer库
ijkplayer，怎么循环播放
谢桥的博客
08-11 743
代码】ijkplayer，怎么循环播放。
开源播放框架ijkplayer（iOS版）使用教程
lanxiaoni的专栏
05-31 989
最近在关注直播这块儿，开始时直接用ffmpeg写了一个，写得比较烂，卡顿很严重，后来听说了B站开源播放框架ijkplayer，于是就去试试看这是链接 ，一用之下果然不错，逢人便向人安利，可总是有部分同学说看不懂、不会用。其实用法都在readme里写得很清楚了，只要照着做就行了。好吧，我知道其实是你们懒得看 -_-!， 那我就在这儿说说大概的步骤吧。 首先配置环境，需要安装 homebrew，gi
bilibili的直播第三方IJKMediaFramework.framework下载打包使用教程
diankuini1374的博客
06-13 288
参考和引用的地址： http://www.code4app.com/thread-8941-1-1.html http://blog.csdn.net/cccallen/article/details/8440153 ijkplayer下载地址 1.从GitHub下载安装文件，下载完成后解压 2.编译 ijkplayer 说是编译 ijkplayer, 其实是编...
iOS之IJKPlayer集成框架-IJKMediaFramework（支持RTSP等多种视频流，并解决了iOS11有声音没图像问题）
07-21
IJKPlayer集成框架，可以直接拿去用。支持rtsp、rtmp等多种视频流，并解决了在iOS11中出现的有声音没图像的问题，而且这个框架在真机和模拟器上都能用的。
ffmpag.rar_android_android ijkplayer_ijkplayer_ijkplayer播放器
09-14
ijkplayer是一款开源的跨平台多媒体框架，源自FFmpeg项目，专为Android和iOS等移动设备设计。在Android平台上，ijkplayer被广泛应用于各种应用程序中，因为它提供了强大的视频和音频播放功能，支持多种编码格式，...
IOS－使用ijkplayer简单demo
01-13
在iOS开发中，ijkplayer是一个常用的开源视频播放器库，由Bilibili贡献，它基于FFmpeg，并提供了更友好的接口来实现视频播放功能。这个"IOS－使用ijkplayer简单demo"是一个帮助开发者快速理解并集成ijkplayer到iOS...
swift-iOS平台下基于IJKplayer封装的视频播放器
08-15
在iOS平台上，开发一款视频播放器是常见的需求，而基于IJKplayer的封装可以提供高效、稳定且功能丰富的解决方案。IJKplayer是由Bilibili开源的一款跨平台的媒体播放库，支持iOS和Android，它基于FFmpeg进行了优化，...
Android代码-一个视频播放列表demo，视频播放使用的ijkplayer
08-06
VideoListDemo 一个视频播放列表demo，视频播放使用的ijkplayer,正在播放视频拖动到不可见区域小窗口播放，可全屏切换
使用IJKPlayer播放视频实现了一些播放视频的基本操作
04-02
使用ijkplayer实现了播放、暂停、旋转全屏播放、音量和亮度调节、进度条、拖动进度条播放功能*，可以满足普通的播放视频的需求
Android代码-基于IjkPlayer的视频播放器，支持一行代码切换MediaPlayer和ExoPlayer
08-08
DKPlayer A video player based on IjkPlayer. ------ demo下载 ------ 特性 支持直播和点播。 支持调整显示比例:默认、原始大小、16:9、4:3、铺满屏幕、居中裁剪。 支持滑动调节播放进度、声音、亮度；双击播放、暂停；保存播放进度。 支持边播边缓存，使用了AndroidVideoCache。 支持弹幕，使用了DanmakuFlameMaster。 支持Https，rtsp，concat协议。 支持播放本地视频以及raw和assets视频。 支持重力感应自动进入/退出全屏以及手动进入/退出全屏，全屏状态下可锁定。 完美实现列表播放（RecyclerView和ListView），列表自动播放。 支持列表小窗全局悬浮播放，Android 8.0画中画功能。 支持连续播放一个列表的视频。 支持广告播放。 支持清晰度切换。 支持扩展自定义播放内核，MediaPlayer、ExoPlayer、vitamio等。 支持完全自定义控制层。 支持多路播放器同时播放，没有任何控制UI的纯播放 抖音demo。使用 1.添加类库 gradl
Android代码-基于IJKPlayer的多功能视频播放器
08-06
基于IJKPlayer，实现了多功能的视频播放器。 支持基本的拖动，声音、亮度调节。 支持边播边缓存，使用了AndroidVideoCache。 支持视频本身自带rotation的旋转。 增加了重力旋转与手动旋转的同步支持。 支持列表播放。 直接添加控件为封面。 全屏和播放等的动画效果。 列表的全屏效果优化，多种配置模式。 列表的小窗口播放，可拖动。 网络视频加载速度。 锁定/解锁全屏点击功能。 支持快播和慢播。 调整显示比例:默认、16:9、4:3。 暂停时前后台切换不黑屏 调整不同清晰度的支持。 支持IJKPlayer和EXOPlayer切换。 进度条小窗口预览（测试）。 Https支持。 支持播放时旋转画面角度（0,90,180,270）。 连续播放一个列表的视频。 支持全屏与非全屏两套布局切换 弹幕支持 镜像旋转 使用依赖(支持jcenter和jitpack) 1、JCenter 引入方法 直接在module下的build.gradle添加 compile 'com.shuyu:GSYVideoPlayer:1.6.7' 2、JitPack引入方法 在proj
ijkplayer 消息循环处理过程分析
万事亨通
03-03 414
ijkplayer 消息循环处理过程分析简介一、消息队列初始化1、 initWithContentURLString函数2、 ijkmp_ios_create函数3、 ijkmp_create函数二、消息队列的消息循环处理函数启动1、prepareToPlay函数2、ijkmp_prepare_async函数3、ijkmp_prepare_async_l函数4、ijkmp_msg_loop函数三、消息循环处理1、 media_player_msg_loop消息循环函数2、 ijkmp_get_msg函数3、
使用ijkplayer进行视频播放
热门推荐
专栏
09-22 1万+
ijkplayer可以支持网络和本地的视频播放，注意路径就可以了 先来看一下代码吧，里面添加了音量，亮度调节，只限在这个播放页面内，我感觉这是合理的，不要在自己的应用内动了用户的手机的配置又不去复原。 先来上一张图：动图太大了，上传失败，就放了一张png activity：package com.fanyafeng.testijkplayer.activity;import android
Ijkplay 视频播放
笔片
11-28 810
今天写一下简单的Ijkplay的视频播放，很简单的，通过第三方的依赖，就可以简单的实现播放的功能了。 接下来按照步骤走就可以了， 第一步，导入第三方的依赖： compile 'com.dou361.ijkplayer:jjdxm-ijkplayer:1.0.5' 第二步，进行布局： <include layout="@layout/simple_player_view_
iOS-ijkplayer框架的集成
SSY_1992的博客
01-30 3221
ijkplayer 是一个基于 ffplay 的轻量级 Android/iOS 视频播放器。实现了跨平台功能，API易于集成；编译配置可裁剪，方便控制安装包大小；支持硬件加速解码，更加省电，此方案目前已用于美拍和斗鱼 APP，说明ijkplayer是经得起考验的，当然用第三方SDK是最方便的，如七牛、腾讯、阿里都很好。 第一步 ：到git上面下载 ijkplayer-master 1.手动到g
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值