Subversion Repositories Kolibri OS

Compare Revisions

Regard whitespace Rev 6143 → Rev 6144

/contrib/media/fplay/Makefile
1,4 → 1,3
 
NAME= Fplay
 
FASM= fasm.exe
27,6 → 26,7
 
SOURCES = opendial.asm \
audio.c \
decoder.c \
fplay.c \
vaapi.c \
video.c \
/contrib/media/fplay/audio.c
29,10 → 29,7
int sample_rate;
 
static uint32_t samples_written = 0;
double audio_base = -1.0;
 
double get_audio_base();
 
int init_audio(int format)
{
int err;
128,14 → 125,6
int data_size = av_samples_get_buffer_size(&plane_size, ctx->channels,
aFrame->nb_samples,
ctx->sample_fmt, 1);
 
// if(audio_base == -1.0)
// {
// if (pkt.pts != AV_NOPTS_VALUE)
// audio_base = get_audio_base() * pkt.pts;
// printf("audio base %f\n", audio_base);
// };
 
pkt_tmp.data += len;
pkt_tmp.size -= len;
 
254,6 → 243,7
 
int audio_thread(void *param)
{
vst_t *vst = param;
SND_EVENT evnt;
 
int buffsize;
306,11 → 296,10
memcpy(astream.buffer, astream.buffer+buffsize*2, astream.count);
mutex_unlock(&astream.lock);
 
SetTimeBase(hBuff, audio_base);
SetTimeBase(hBuff, vst->audio_timer_base);
 
case PAUSE_2_PLAY:
GetTimeStamp(hBuff, &last_time_stamp);
// printf("last audio time stamp %f\n", last_time_stamp);
 
if((err = PlayBuffer(hBuff, 0)) !=0 )
{
320,7 → 309,6
active = 1;
sync_audio(hBuff, buffsize);
sound_state = PLAY;
// printf("render: set audio latency to %f\n", audio_delta);
 
/* breaktrough */
 
385,7 → 373,7
if( active )
{
ResetBuffer(hBuff, SND_RESET_ALL);
audio_base = -1.0;
vst->audio_timer_valid = 0;
active = 0;
}
sound_state = STOP;
/contrib/media/fplay/decoder.c
0,0 → 1,232
#include <stdint.h>
 
#include <libavcodec/avcodec.h>
#include <libavformat/avformat.h>
#include <libavutil/imgutils.h>
 
#include <stdio.h>
#include <string.h>
#include <fcntl.h>
#include <ctype.h>
#include <kos32sys.h>
#include "winlib/winlib.h"
 
#include "sound.h"
#include "fplay.h"
 
static struct decoder* init_ffmpeg_decoder(vst_t *vst)
{
AVCodecContext *vCtx = vst->vCtx;
struct decoder *decoder;
vframe_t *vframe;
int i, ret;
 
decoder = calloc(1, sizeof(struct decoder));
if(decoder == NULL)
return NULL;
 
decoder->Frame = av_frame_alloc();
if(decoder->Frame == NULL)
goto err_0;
 
decoder->nframes = 4;
 
for(i = 0; i < decoder->nframes; i++)
{
vframe = &decoder->vframes[i];
 
ret = avpicture_alloc(&vframe->picture, vCtx->pix_fmt,
vCtx->width, vCtx->height);
if ( ret != 0 )
goto err_1;
 
vframe->format = vCtx->pix_fmt;
vframe->index = i;
vframe->pts = 0;
vframe->ready = 0;
list_add_tail(&vframe->list, &vst->input_list);
};
 
if(avcodec_open2(vCtx, vst->vCodec, NULL) < 0)
{
printf("Error while opening codec for input stream %d\n",
vst->vStream);
goto err_1;
};
 
decoder->name = vst->vCodec->name;
decoder->pix_fmt = vCtx->pix_fmt;
decoder->width = vCtx->width;
decoder->height = vCtx->height;
decoder->codec_id = vCtx->codec_id;
 
return decoder;
 
err_1:
for(i = i-1; i >= 0; i--)
{
vframe = &decoder->vframes[i];
avpicture_free(&vframe->picture);
};
av_frame_free(&decoder->Frame);
err_0:
free(decoder);
return NULL;
}
 
int init_video_decoder(vst_t *vst)
{
AVCodecContext *vCtx = vst->vCtx;
 
vst->vCodec = avcodec_find_decoder(vCtx->codec_id);
 
if(vst->vCodec == NULL)
{
printf("Unsupported codec with id %d for input stream %d\n",
vst->vCtx->codec_id, vst->vStream);
return -1;
}
 
vst->decoder = va_init_decoder(vst);
if(vst->decoder == NULL)
vst->decoder = init_ffmpeg_decoder(vst);
 
if(vst->decoder != NULL)
{
printf("%dx%d %s %s%s decoder\n",
vst->decoder->width, vst->decoder->height,
av_get_pix_fmt_name(vst->decoder->pix_fmt),
vst->decoder->is_hw == 0 ? "ffmpeg ":"vaapi ",
vst->decoder->name);
 
return 0;
};
 
return -1;
}
 
void fini_video_decoder(vst_t *vst)
{
avcodec_close(vst->vCtx);
 
if(vst->decoder->is_hw != 0)
return;
 
for(int i = 0; i < vst->decoder->nframes; i++)
{
vframe_t *vframe;
vframe = &vst->decoder->vframes[i];
avpicture_free(&vframe->picture);
};
av_frame_free(&vst->decoder->Frame);
free(vst->decoder);
};
 
static vframe_t *get_input_frame(vst_t *vst)
{
vframe_t *vframe = NULL;
 
mutex_lock(&vst->input_lock);
if(!list_empty(&vst->input_list))
{
vframe = list_first_entry(&vst->input_list, vframe_t, list);
list_del(&vframe->list);
}
mutex_unlock(&vst->input_lock);
 
return vframe;
}
 
static void put_output_frame(vst_t *vst, vframe_t *vframe)
{
mutex_lock(&vst->output_lock);
if(list_empty(&vst->output_list))
list_add_tail(&vframe->list, &vst->output_list);
else
{
vframe_t *cur;
 
cur = list_first_entry(&vst->output_list,vframe_t,list);
if(vframe->pts < cur->pts)
list_add_tail(&vframe->list, &vst->output_list);
else
{
list_for_each_entry_reverse(cur,&vst->output_list,list)
{
if(vframe->pts > cur->pts)
{
list_add(&vframe->list, &cur->list);
break;
};
};
};
};
vst->frames_count++;
mutex_unlock(&vst->output_lock);
};
 
int decode_video(vst_t* vst)
{
struct decoder* decoder = vst->decoder;
double pts;
AVPacket pkt;
 
int frameFinished;
 
if(decoder->active_frame == NULL)
decoder->active_frame = get_input_frame(vst);
 
if(decoder->active_frame == NULL)
return -1;
 
if( get_packet(&vst->q_video, &pkt) == 0 )
return 0;
 
frameFinished = 0;
 
mutex_lock(&vst->gpu_lock);
 
if(avcodec_decode_video2(vst->vCtx, decoder->Frame, &frameFinished, &pkt) <= 0)
printf("video decoder error\n");
 
if(frameFinished)
{
vframe_t *vframe = decoder->active_frame;
AVPicture *dst_pic;
 
if(decoder->is_hw)
pts = pkt.pts;
else
pts = av_frame_get_best_effort_timestamp(decoder->Frame);
 
pts*= av_q2d(vst->video_time_base);
 
dst_pic = &vframe->picture;
 
if(vframe->is_hw_pic == 0)
av_image_copy(dst_pic->data, dst_pic->linesize,
(const uint8_t**)decoder->Frame->data,
decoder->Frame->linesize, vst->vCtx->pix_fmt, vst->vCtx->width, vst->vCtx->height);
else
va_create_planar(vst, vframe);
 
vframe->pts = pts*1000.0;
vframe->pkt_pts = pkt.pts*av_q2d(vst->video_time_base)*1000.0;
vframe->ready = 1;
 
put_output_frame(vst, vframe);
 
// printf("decoded index: %d pts: %f pkt_pts %f pkt_dts %f\n",
// vst->dfx, vst->vframe[vst->dfx].pts,
// vst->vframe[vst->dfx].pkt_pts, vst->vframe[vst->dfx].pkt_dts);
 
decoder->active_frame = NULL;
};
av_frame_unref(decoder->Frame);
mutex_unlock(&vst->gpu_lock);
 
av_free_packet(&pkt);
 
return 1;
}
 
/contrib/media/fplay/fplay.c
22,8 → 22,6
 
uint32_t win_width, win_height;
 
int have_sound = 0;
 
uint8_t *decoder_buffer;
extern int resampler_size;
extern int sample_rate;
34,9 → 32,7
 
int threads_running = DECODER_THREAD;
 
extern double audio_base;
 
 
int main( int argc, char *argv[])
{
static vst_t vst;
70,7 → 66,6
 
vst.fCtx->flags |= AVFMT_FLAG_GENPTS;
 
// Retrieve stream information
if(avformat_find_stream_info(vst.fCtx, NULL) < 0)
{
printf("Cannot find streams\n\r");
89,7 → 84,6
 
stream_duration = vst.fCtx->duration;
 
// Find the first video stream
vst.vStream = -1;
vst.aStream = -1;
 
108,7 → 102,6
vst.aStream < 0)
{
vst.aStream = i;
vst.audio_time_base = vst.fCtx->streams[i]->time_base;
if(stream_duration == 0)
stream_duration = vst.fCtx->streams[i]->duration;
}
122,12 → 115,6
 
// __asm__ __volatile__("int3");
 
// Get a pointer to the codec context for the video stream
vst.vCtx = vst.fCtx->streams[vst.vStream]->codec;
vst.aCtx = vst.fCtx->streams[vst.aStream]->codec;
 
vst.vCodec = avcodec_find_decoder(vst.vCtx->codec_id);
 
INIT_LIST_HEAD(&vst.input_list);
INIT_LIST_HEAD(&vst.output_list);
mutex_init(&vst.q_video.lock);
137,37 → 124,14
mutex_init(&vst.input_lock);
mutex_init(&vst.output_lock);
 
if(vst.vCodec == NULL)
{
printf("Unsupported codec with id %d for input stream %d\n",
vst.vCtx->codec_id, vst.vStream);
return -1;
}
vst.vCtx = vst.fCtx->streams[vst.vStream]->codec;
vst.aCtx = vst.fCtx->streams[vst.aStream]->codec;
 
vst.Frame = av_frame_alloc();
if(vst.Frame == NULL)
{
printf("Cannot alloc video frame\n");
if(init_video_decoder(&vst) != 0 )
return -1;
};
 
if(fplay_init_context(&vst))
return -1;
 
if(avcodec_open2(vst.vCtx, vst.vCodec, NULL) < 0)
{
printf("Error while opening codec for input stream %d\n",
vst.vStream);
return -1; // Could not open codec
};
 
if (vst.aCtx->channels > 0)
vst.aCtx->request_channels = FFMIN(2, vst.aCtx->channels);
else
vst.aCtx->request_channels = 2;
 
vst.aCtx->request_channel_layout = AV_CH_LAYOUT_STEREO;
vst.aCodec = avcodec_find_decoder(vst.aCtx->codec_id);
 
if(vst.aCodec)
{
if(avcodec_open2(vst.aCtx, vst.aCodec, NULL) >= 0 )
198,11 → 162,11
astream.count = 0;
astream.buffer = (char *)av_mallocz(192000*3);
if( astream.buffer != NULL )
have_sound = 1;
vst.has_sound = 1;
else
av_free(decoder_buffer);
}
if( have_sound == 0)
if( vst.has_sound == 0)
{
printf("Not enough memory for audio buffers\n");
}
229,9 → 193,11
if(astream.lock.handle)
mutex_destroy(&astream.lock);
 
fini_video_decoder(&vst);
mutex_destroy(&vst.q_video.lock);
mutex_destroy(&vst.q_audio.lock);
mutex_destroy(&vst.decoder_lock);
 
return 0;
}
 
247,14 → 213,14
if(packet.stream_index == vst->vStream)
put_packet(&vst->q_video, &packet);
else if( (packet.stream_index == vst->aStream) &&
(have_sound != 0) )
(vst->has_sound != 0) )
{
put_packet(&vst->q_audio, &packet);
if(audio_base == -1.0)
if(vst->audio_timer_valid == 0 &&
packet.pts != AV_NOPTS_VALUE )
{
if (packet.pts != AV_NOPTS_VALUE)
audio_base = get_audio_base(vst) * packet.pts;
// printf("audio base %f\n", audio_base);
vst->audio_timer_base = get_audio_base(vst) * packet.pts;
vst->audio_timer_valid = 1;
};
}
else av_free_packet(&packet);
/contrib/media/fplay/fplay.h
110,6 → 110,22
int put_packet(queue_t *q, AVPacket *pkt);
int get_packet(queue_t *q, AVPacket *pkt);
 
struct decoder
{
const char *name;
enum AVCodecID codec_id;
enum AVPixelFormat pix_fmt;
int width;
int height;
AVFrame *Frame;
vframe_t *active_frame;
void *hwctx;
int is_hw:1;
int frame_reorder:1;
int nframes;
vframe_t vframes[16];
};
 
struct vstate
{
AVFormatContext *fCtx; /* format context */
122,7 → 138,7
int vStream; /* video stream index */
int aStream; /* audio stream index */
AVRational video_time_base;
AVRational audio_time_base;
double audio_timer_base;
 
queue_t q_video; /* video packets queue */
queue_t q_audio; /* audio packets queue */
135,18 → 151,13
struct list_head input_list;
struct list_head output_list;
 
AVFrame *Frame;
 
vframe_t *decoder_frame;
struct decoder *decoder;
volatile int frames_count;
void *hwCtx; /* hardware context */
int hwdec:1; /* hardware decoder */
int has_sound:1;
int audio_timer_valid:1;
int blit_bitmap:1; /* hardware RGBA blitter */
int blit_texture:1; /* hardware RGBA blit and scale */
int blit_planar:1; /* hardbare YUV blit and scale */
int frame_reorder:1;
int nframes;
vframe_t vframes[16];
};
 
 
173,6 → 184,8
int video_thread(void *param);
void flush_video(vst_t* vst);
 
int init_video_decoder(vst_t *vst);
void fini_video_decoder(vst_t *vst);
void decoder(vst_t *vst);
int decode_video(vst_t* vst);
int decode_audio(AVCodecContext *ctx, queue_t *qa);
191,8 → 204,13
return (double)av_q2d(vst->fCtx->streams[vst->aStream]->time_base)*1000;
};
 
struct decoder* va_init_decoder(vst_t *vst);
void va_create_planar(vst_t *vst, vframe_t *vframe);
 
int init_fontlib();
char *get_moviefile();
 
#define ENTER() printf("enter %s\n",__FUNCTION__)
#define LEAVE() printf("leave %s\n",__FUNCTION__)
#define FAIL() printf("fail %s\n",__FUNCTION__)
 
/contrib/media/fplay/vaapi.c
160,22 → 160,7
return "<unknown>";
}
 
VADisplay va_open_display(void)
{
VADisplay va_dpy;
 
drm_fd = get_service("DISPLAY");
if (drm_fd == 0)
return NULL;
 
va_dpy = vaGetDisplayDRM(drm_fd);
if (va_dpy)
return va_dpy;
 
drm_fd = 0;
return NULL;
};
 
void *vaapi_init(VADisplay display)
{
struct vaapi_context *vaapi;
343,7 → 328,7
 
printf("vaCreateSurfaces %dx%d\n",picture_width,picture_height);
status = vaCreateSurfaces(vaapi->display, VA_RT_FORMAT_YUV420, picture_width, picture_height,
v_surface_id,vst->nframes,NULL,0);
v_surface_id,vst->decoder->nframes,NULL,0);
if (!vaapi_check_status(status, "vaCreateSurfaces()"))
{
FAIL();
378,7 → 363,7
status = vaCreateContext(vaapi->display, config_id,
picture_width, picture_height,
VA_PROGRESSIVE,
v_surface_id, vst->nframes,
v_surface_id, vst->decoder->nframes,
&context_id);
if (!vaapi_check_status(status, "vaCreateContext()"))
{
399,7 → 384,7
vst_t *vst = (vst_t*)avctx->opaque;
VAProfile profile = VAProfileNone;
 
 
ENTER();
for (int i = 0; fmt[i] != PIX_FMT_NONE; i++)
{
enum AVCodecID codec = avctx->codec_id;
449,7 → 434,7
vst_t *vst = (vst_t*)avctx->opaque;
void *surface;
 
surface = (void *)(uintptr_t)v_surface_id[vst->decoder_frame->index];
surface = (void *)(uintptr_t)v_surface_id[vst->decoder->active_frame->index];
 
pic->data[3] = surface;
 
466,73 → 451,8
 
struct vaapi_context va_context_storage;
 
int fplay_init_context(vst_t *vst)
{
AVCodecContext *vCtx = vst->vCtx;
 
vst->nframes = 4;
 
if(va_check_codec_support(vCtx->codec_id))
{
VADisplay dpy;
 
dpy = va_open_display();
vst->hwCtx = vaapi_init(dpy);
 
if(vst->hwCtx != NULL)
{
if(vCtx->codec_id == AV_CODEC_ID_H264)
vst->nframes = 16;
 
for(int i = 0; i < vst->nframes; i++)
{
vframe_t *vframe = &vst->vframes[i];
 
vframe->format = AV_PIX_FMT_NONE;
vframe->is_hw_pic = 1;
vframe->index = i;
vframe->pts = 0;
vframe->ready = 0;
list_add_tail(&vframe->list, &vst->input_list);
};
 
vst->hwdec = 1;
vst->frame_reorder = 1;
vCtx->opaque = vst;
vCtx->thread_count = 1;
vCtx->get_format = get_format;
vCtx->get_buffer2 = get_buffer2;
return 0;
};
};
 
vst->hwdec = 0;
 
for(int i = 0; i < vst->nframes; i++)
{
vframe_t *vframe;
int ret;
 
vframe = &vst->vframes[i];
 
ret = avpicture_alloc(&vframe->picture, vst->vCtx->pix_fmt,
vst->vCtx->width, vst->vCtx->height);
if ( ret != 0 )
{
printf("Cannot alloc video buffer\n\r");
return ret;
};
vframe->format = vst->vCtx->pix_fmt;
vframe->index = i;
vframe->pts = 0;
vframe->ready = 0;
list_add_tail(&vframe->list, &vst->input_list);
};
 
return 0;
}
 
 
#define EGL_TEXTURE_Y_U_V_WL 0x31D7
#define EGL_TEXTURE_Y_UV_WL 0x31D8
#define EGL_TEXTURE_Y_XUXV_WL 0x31D9
648,7 → 568,6
vaimage.offsets[2],vaimage.pitches[2]);
if(planar != NULL)
{
printf("create planar image\n",planar);
vframe->planar = planar;
vframe->format = AV_PIX_FMT_NV12;
};
657,3 → 576,78
vaDestroyImage(vaapi->display, vaimage.image_id);
 
}
 
struct decoder* va_init_decoder(vst_t *vst)
{
AVCodecContext *vCtx = vst->vCtx;
struct decoder *decoder;
VADisplay dpy;
 
drm_fd = get_service("DISPLAY");
if (drm_fd == 0)
return NULL;
 
dpy = vaGetDisplayDRM(drm_fd);
if (dpy == NULL)
goto err_0;
 
decoder = calloc(1, sizeof(struct decoder));
if(decoder == NULL)
goto err_0;
 
decoder->hwctx = vaapi_init(dpy);
if(decoder->hwctx == NULL)
goto err_1;
 
decoder->Frame = av_frame_alloc();
if(decoder->Frame == NULL)
goto err_1;
 
if(vCtx->codec_id == AV_CODEC_ID_H264)
decoder->nframes = 16;
else
decoder->nframes = 4;
 
for(int i = 0; i < decoder->nframes; i++)
{
vframe_t *vframe = &decoder->vframes[i];
 
vframe->format = AV_PIX_FMT_NONE;
vframe->is_hw_pic = 1;
vframe->index = i;
vframe->pts = 0;
vframe->ready = 0;
list_add_tail(&vframe->list, &vst->input_list);
};
 
vCtx->opaque = vst;
vCtx->thread_count = 1;
vCtx->get_format = get_format;
vCtx->get_buffer2 = get_buffer2;
 
if(avcodec_open2(vst->vCtx, vst->vCodec, NULL) < 0)
{
printf("Error while opening codec for input stream %d\n",
vst->vStream);
goto err_2;
};
 
decoder->name = vst->vCodec->name;
decoder->codec_id = vCtx->codec_id;
decoder->pix_fmt = vCtx->pix_fmt;
decoder->width = vCtx->width;
decoder->height = vCtx->height;
decoder->is_hw = 1;
decoder->frame_reorder = 1;
 
return decoder;
 
err_2:
av_frame_free(&decoder->Frame);
err_1:
free(decoder);
vaTerminate(dpy);
err_0:
drm_fd = 0;
return NULL;
}
/contrib/media/fplay/video.c
40,7 → 40,7
list_for_each_entry_safe(vframe, tmp, &vst->output_list, list)
list_move_tail(&vframe->list, &vst->input_list);
 
list_for_each_entry(vframe, &vst->output_list, list)
list_for_each_entry(vframe, &vst->input_list, list)
{
vframe->pts = 0;
vframe->ready = 0;
52,113 → 52,7
};
 
 
static vframe_t *get_input_frame(vst_t *vst)
{
vframe_t *vframe = NULL;
 
mutex_lock(&vst->input_lock);
if(!list_empty(&vst->input_list))
{
vframe = list_first_entry(&vst->input_list, vframe_t, list);
list_del(&vframe->list);
}
mutex_unlock(&vst->input_lock);
 
return vframe;
}
 
static void put_output_frame(vst_t *vst, vframe_t *vframe)
{
mutex_lock(&vst->output_lock);
if(list_empty(&vst->output_list))
list_add_tail(&vframe->list, &vst->output_list);
else
{
vframe_t *cur;
 
cur = list_first_entry(&vst->output_list,vframe_t,list);
if(vframe->pts < cur->pts)
list_add_tail(&vframe->list, &vst->output_list);
else
{
list_for_each_entry_reverse(cur,&vst->output_list,list)
{
if(vframe->pts > cur->pts)
{
list_add(&vframe->list, &cur->list);
break;
};
};
};
};
vst->frames_count++;
mutex_unlock(&vst->output_lock);
};
 
int decode_video(vst_t* vst)
{
double pts;
AVPacket pkt;
 
int frameFinished;
 
if(vst->decoder_frame == NULL)
vst->decoder_frame = get_input_frame(vst);
 
if(vst->decoder_frame == NULL)
return -1;
 
if( get_packet(&vst->q_video, &pkt) == 0 )
return 0;
 
frameFinished = 0;
 
mutex_lock(&vst->gpu_lock);
 
if(avcodec_decode_video2(vst->vCtx, vst->Frame, &frameFinished, &pkt) <= 0)
printf("video decoder error\n");
 
if(frameFinished)
{
vframe_t *vframe = vst->decoder_frame;;
AVPicture *dst_pic;
 
if(vst->hwdec)
pts = pkt.pts;
else
pts = av_frame_get_best_effort_timestamp(vst->Frame);
 
pts*= av_q2d(vst->video_time_base);
 
dst_pic = &vframe->picture;
 
if(vframe->is_hw_pic == 0)
av_image_copy(dst_pic->data, dst_pic->linesize,
(const uint8_t**)vst->Frame->data,
vst->Frame->linesize, vst->vCtx->pix_fmt, vst->vCtx->width, vst->vCtx->height);
else
va_create_planar(vst, vframe);
 
vframe->pts = pts*1000.0;
vframe->pkt_pts = pkt.pts*av_q2d(vst->video_time_base)*1000.0;
vframe->ready = 1;
 
put_output_frame(vst, vframe);
 
// printf("decoded index: %d pts: %f pkt_pts %f pkt_dts %f\n",
// vst->dfx, vst->vframe[vst->dfx].pts,
// vst->vframe[vst->dfx].pkt_pts, vst->vframe[vst->dfx].pkt_dts);
 
vst->decoder_frame = NULL;
};
av_frame_unref(vst->Frame);
mutex_unlock(&vst->gpu_lock);
 
av_free_packet(&pkt);
 
return 1;
}
 
extern volatile enum player_state player_state;
extern volatile enum player_state decoder_state;
extern volatile enum player_state sound_state;
482,6 → 376,18
 
__sync_and_and_fetch(&threads_running,~VIDEO_THREAD);
 
{
vframe_t *vframe, *tmp;
flush_video(vst);
 
list_for_each_entry_safe(vframe, tmp, &vst->output_list, list)
{
list_del(&vframe->list);
if(vframe->planar != NULL)
pxDestroyPlanar(vframe->planar);
}
}
 
destroy_render(main_render);
fini_winlib();
player_state = CLOSED;
737,7 → 643,6
CAPTION_HEIGHT+render->rcvideo.t,
render->rcvideo.r, render->rcvideo.b,0,0);
mutex_unlock(&render->vst->gpu_lock);
 
}
};
 
770,7 → 675,7
dst_height = render->rcvideo.b;
};
 
if(vst->hwdec)
if(vframe->is_hw_pic)
{
render_hw_planar(render, vframe);
return;
778,7 → 683,7
 
picture = &vframe->picture;
 
format = render->vst->hwdec == 0 ? render->ctx_format : AV_PIX_FMT_BGRA;
format = render->ctx_format;
cvt_ctx = sws_getCachedContext(cvt_ctx, render->ctx_width, render->ctx_height, format,
dst_width, dst_height, AV_PIX_FMT_BGRA,
SWS_FAST_BILINEAR, NULL, NULL, NULL);
/contrib/media/fplay/winlib/button.c
16,6 → 16,7
 
static int button_proc(ctrl_t *btn, uint32_t msg, uint32_t arg1, uint32_t arg2);
static int spinbtn_proc(ctrl_t *btn, uint32_t msg, uint32_t arg1, uint32_t arg2);
void panel_set_layout(ctrl_t *panel, int layout);
 
ctrl_t *create_control(size_t size, int id, int x, int y,
int w, int h, ctrl_t *parent)
/contrib/media/fplay/winlib/caption.c
25,6 → 25,8
extern uint32_t main_cursor;
 
void update_caption_size(window_t *win);
void window_update_layout(window_t *win);
int draw_text_ext(void *pixmap, uint32_t pitch, int face, char *text, rect_t *rc, int color);
 
int caption_proc(ctrl_t *ctrl, uint32_t msg, uint32_t arg1, uint32_t arg2);
 
/contrib/media/fplay/winlib/control.h
203,6 → 203,7
ctrl_t *get_child(ctrl_t *ctrl, int x, int y);
 
ctrl_t *capture_mouse(ctrl_t *newm);
void release_mouse(void);
 
void blit_raw(ctx_t *ctx, void *raw, int x, int y, int w, int h, int pitch);
 
/contrib/media/fplay/winlib/window.c
38,6 → 38,7
void blit_panel(panel_t *panel);
void update_panel_size(window_t *win);
void update_caption_size(window_t *win);
int init_fontlib();
 
//#include "timer.h"
ctrl_t *win_get_child(window_t *win, int x, int y)