WebSVN – Kolibri OS – Diff – /contrib/media/fplay/video.c

 AVRational video_time_base;
 AVFrame  *Frame;
-extern mutex_t driver_lock;
 void get_client_rect(rect_t *rc);
 void flush_video()
     vfx    = 0;
     dfx    = 0;
 };
-int init_video(AVCodecContext *ctx)
+int init_video(vst_t *vst)
+{
     int        i;
-    width = ctx->width;
+    width = vst->vCtx->width;
-    height = ctx->height;
+    height = vst->vCtx->height;
-    Frame = avcodec_alloc_frame();
+    Frame = av_frame_alloc();
     if ( Frame == NULL )
+    {
         printf("Cannot alloc video frame\n\r");
         return 0;
     };
     for( i=0; i < 4; i++)
     {
         int ret;
-        ret = avpicture_alloc(&frames[i].picture, ctx->pix_fmt,
+        ret = avpicture_alloc(&frames[i].picture, vst->vCtx->pix_fmt,
-                               ctx->width, ctx->height);
+                               vst->vCtx->width, vst->vCtx->height);
         if ( ret != 0 )
+        {
             printf("Cannot alloc video buffer\n\r");
             return 0;
         };
         frames[i].pts    = 0;
         frames[i].ready  = 0;
     };
-    create_thread(video_thread, ctx, 1024*1024);
+    create_thread(video_thread, vst, 1024*1024);
     delay(50);
     return 1;
 };
-int decode_video(AVCodecContext  *ctx, queue_t *qv)
+int decode_video(vst_t* vst)
+{
     AVPacket   pkt;
     double     pts;
     if( 1 /*pts > current_clock*/)
+    {
         frameFinished = 0;
-        ctx->reordered_opaque = pkt.pts;
+        vst->vCtx->reordered_opaque = pkt.pts;
+        mutex_lock(&vst->gpu_lock);
-        if(avcodec_decode_video2(ctx, Frame, &frameFinished, &pkt) <= 0)
+        if(avcodec_decode_video2(vst->vCtx, Frame, &frameFinished, &pkt) <= 0)
             printf("video decoder error\n");
         if(frameFinished)
             dst_pic = &frames[dfx].picture;
             av_image_copy(dst_pic->data, dst_pic->linesize,
                       (const uint8_t**)Frame->data,
-                      Frame->linesize, ctx->pix_fmt, ctx->width, ctx->height);
+                      Frame->linesize, vst->vCtx->pix_fmt, vst->vCtx->width, vst->vCtx->height);
             frames[dfx].pts = pts*1000.0;
             frames[dfx].ready = 1;
+            dfx++;
+            dfx&= 3;
-            dfx++;
+            frames_count++;
-            dfx&= 3;
+        };
-            frames_count++;
+        mutex_unlock(&vst->gpu_lock);
         };
 };
 #define VERSION_A     1
-extern queue_t  q_video;
-extern queue_t  q_audio;
 void render_time(render_t *render)
+{
     progress_t  *prg = main_render->win->panel.prg;
 extern char *movie_file;
 int video_thread(void *param)
 {
-    AVCodecContext *ctx = param;
+    vst_t *vst = param;
     window_t  *MainWindow;
     MainWindow->panel.prg->max = stream_duration;
-    show_window(MainWindow, NORMAL);
-//    __asm__ __volatile__("int3");
+    show_window(MainWindow, NORMAL);
-    main_render = create_render(MainWindow, ctx, HW_TEX_BLIT|HW_BIT_BLIT);
+    main_render = create_render(vst, MainWindow, HW_TEX_BLIT|HW_BIT_BLIT);
     if( main_render == NULL)
+    {
         printf("Cannot create render\n\r");
 void draw_hw_picture(render_t *render, AVPicture *picture);
 void draw_sw_picture(render_t *render, AVPicture *picture);
-render_t *create_render(window_t *win, AVCodecContext *ctx, uint32_t flags)
+render_t *create_render(vst_t *vst, window_t *win, uint32_t flags)
+{
     render_t *render;
     render = (render_t*)malloc(sizeof(render_t));
     memset(render, 0, sizeof(render_t));
     render->vst = vst;
     render->win = win;
-    render->ctx_width  = ctx->width;
+    render->ctx_width  = vst->vCtx->width;
-    render->ctx_height = ctx->height;
+    render->ctx_height = vst->vCtx->height;
-    render->ctx_format = ctx->pix_fmt;
+    render->ctx_format = vst->vCtx->pix_fmt;
     };
     cvt_ctx = sws_getCachedContext(cvt_ctx,
               render->ctx_width, render->ctx_height, render->ctx_format,
-              dst_width, dst_height, PIX_FMT_BGRA,
+              dst_width, dst_height, AV_PIX_FMT_BGRA,
               SWS_FAST_BILINEAR, NULL, NULL, NULL);
     if(cvt_ctx == NULL)
+    {
         printf("Cannot initialize the conversion context!\n");
         return ;
     sws_scale(cvt_ctx, (const uint8_t* const *)picture->data,
               picture->linesize, 0, render->ctx_height, data, linesize);
 //    printf("sws_scale\n");
     mutex_lock(&render->vst->gpu_lock);
     if(render->caps & HW_TEX_BLIT)
             pxBlitBitmap(bitmap, render->rcvideo.l,
                     CAPTION_HEIGHT+render->rcvideo.t,
                     render->rcvideo.r, render->rcvideo.b, 0, 0);
     };
     mutex_unlock(&render->vst->gpu_lock);
     render->last_bitmap = bitmap;
     render->target++;
     render->target&= 1;
+}
     cvt_ctx = sws_getCachedContext(cvt_ctx,
               render->ctx_width, render->ctx_height,
               render->ctx_format,
               render->rcvideo.r, render->rcvideo.b,
-              PIX_FMT_BGRA, SWS_FAST_BILINEAR, NULL, NULL, NULL);
+              AV_PIX_FMT_BGRA, SWS_FAST_BILINEAR, NULL, NULL, NULL);
     if(cvt_ctx == NULL)
+    {
         printf("Cannot initialize the conversion context!\n");
         return ;
+    }

Subversion Repositories Kolibri OS

(root)/contrib/media/fplay/video.c – Rev 6106 → 6117