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

-render_t   *main_render;
-int width;
-int height;
+render_t   *main_render;
 AVRational video_time_base;
+AVFrame  *Frame;
+void get_client_rect(rect_t *rc);
-AVFrame  *Frame;
+void run_render(window_t *win, void *render);
 void window_update_layout(window_t *win);
-void get_client_rect(rect_t *rc);
+int  fini_winlib();
+void flush_video(vst_t *vst)
+{
+    vframe_t *vframe, *tmp;
+    mutex_lock(&vst->output_lock);
+    mutex_lock(&vst->input_lock);
 void flush_video(vst_t *vst)
-{
+    list_for_each_entry_safe(vframe, tmp, &vst->output_list, list)
-    int i;
+        list_move_tail(&vframe->list, &vst->input_list);
+    list_for_each_entry(vframe, &vst->output_list, list)
-    for(i = 0; i < 4; i++)
+    {
-    {
+        vframe->pts   = 0;
+        vframe->ready = 0;
         vst->vframe[i].pts   = 0;
         vst->vframe[i].ready = 0;
-    };
+    mutex_unlock(&vst->input_lock);
-    vst->vfx = 0;
+    mutex_unlock(&vst->output_lock);
-    vst->dfx = 0;
-    frames_count = 0;
-};
-int init_video(vst_t *vst)
-    int        i;
+    frames_count = 0;
 };
     width  = vst->vCtx->width;
-    height = vst->vCtx->height;
+int init_video(vst_t *vst)
+{
+    Frame = av_frame_alloc();
+    if ( Frame == NULL )
     Frame = av_frame_alloc();
-    if ( Frame == NULL )
         printf("Cannot alloc video frame\n\r");
-        printf("Cannot alloc video frame\n\r");
+        return 0;
+    };
-        return 0;
+    mutex_lock(&vst->decoder_lock);
     };
     create_thread(video_thread, vst, 1024*1024);
     create_thread(video_thread, vst, 1024*1024);
     return 1;
-    delay(50);
-    return 1;
+};
+static double  dts = 0.0;
+int decode_video(vst_t* vst)
+{
-};
+    AVPacket   pkt;
+    double     pts;
+    int frameFinished;
+    if(vst->decoder_frame == NULL)
+    {
+        mutex_lock(&vst->input_lock);
+        if(list_empty(&vst->input_list))
+        {
+            mutex_unlock(&vst->input_lock);
-int decode_video(vst_t* vst)
+            return -1;
+        }
-{
-    AVPacket   pkt;
-    double     pts;
-    int frameFinished;
-    double current_clock;
-    if(vst->vframe[vst->dfx].ready != 0 )
-        return -1;
-    if( get_packet(&vst->q_video, &pkt) == 0 )
-        return 0;
-/*
-    current_clock = -90.0 + get_master_clock();
-    if( pkt.dts == AV_NOPTS_VALUE &&
-        Frame->reordered_opaque != AV_NOPTS_VALUE)
+        vst->decoder_frame = list_first_entry(&vst->input_list, vframe_t, list);
-        pts = Frame->reordered_opaque;
+        list_del(&vst->decoder_frame->list);
-    else if(pkt.dts != AV_NOPTS_VALUE)
+        mutex_unlock(&vst->input_lock);
         pts= pkt.dts;
-    else
+        vframe_t *vframe = vst->decoder_frame;
-        pts= 0;
+    };
     if( get_packet(&vst->q_video, &pkt) == 0 )
+    {
-    pts *= av_q2d(video_time_base)*1000.0;
+        return 0;
-*/
-    if( 1 /*pts > current_clock*/)
+    };
-    {
-        frameFinished = 0;
-        vst->vCtx->reordered_opaque = pkt.pts;
-        mutex_lock(&vst->gpu_lock);
+    frameFinished = 0;
-        if(avcodec_decode_video2(vst->vCtx, Frame, &frameFinished, &pkt) <= 0)
+    if(dts == 0)
-            printf("video decoder error\n");
+        dts = pkt.pts;
-        if(frameFinished)
+    mutex_lock(&vst->gpu_lock);
-            AVPicture *dst_pic;
+    if(avcodec_decode_video2(vst->vCtx, Frame, &frameFinished, &pkt) <= 0)
+        printf("video decoder error\n");
-            if( pkt.dts == AV_NOPTS_VALUE &&
+    if(frameFinished)
+    {
-                Frame->reordered_opaque != AV_NOPTS_VALUE)
+        vframe_t  *vframe;
+        AVPicture *dst_pic;
+        pts = av_frame_get_best_effort_timestamp(Frame);
+        pts *= av_q2d(video_time_base);
+        vframe  = vst->decoder_frame;
+        dst_pic = &vframe->picture;
+        if(vframe->is_hw_pic == 0)
+            av_image_copy(dst_pic->data, dst_pic->linesize,
+                          (const uint8_t**)Frame->data,
+                          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(video_time_base)*1000.0;
+        vframe->pkt_dts = dts*av_q2d(video_time_base)*1000.0;
+        vframe->ready = 1;
+        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->pkt_pts < cur->pkt_pts)
-                pts = Frame->reordered_opaque;
+            {
+                list_add_tail(&vframe->list, &vst->output_list);
+            }
+            else
             else if(pkt.dts != AV_NOPTS_VALUE)
+                list_for_each_entry_reverse(cur,&vst->output_list,list)
                 pts = pkt.dts;
+                    if(vframe->pkt_pts > cur->pkt_pts)
             else
-                pts = 0;
                         list_add(&vframe->list, &cur->list);
-            pts *= av_q2d(video_time_base);
+                        break;
                     };
     };
     return 0;
 };
-#define VERSION_A     1
 void render_time(render_t *render)
+{
     progress_t *prg = main_render->win->panel.prg;
     level_t    *lvl = main_render->win->panel.lvl;
     vst_t      *vst = main_render->vst;
     double      ctime;            /*    milliseconds    */
     double      fdelay;           /*    milliseconds    */
-//again:
     if(player_state == CLOSED)
+    {
         render->win->win_command = WIN_CLOSED;
         return;
         delay(1);
         return;
     };
+    mutex_lock(&vst->output_lock);
+    if(list_empty(&vst->output_list))
+    {
+        mutex_unlock(&vst->output_lock);
-#ifdef VERSION_A
+        delay(1);
+    }
-    if(vst->vframe[vst->vfx].ready == 1 )
+    else
+    {
+        vframe_t *vframe;
         int sys_time;
+        vframe = list_first_entry(&vst->output_list, vframe_t, list);
-        ctime = get_master_clock();
+        list_del(&vframe->list);
-        fdelay = (vst->vframe[vst->vfx].pts - ctime);
+        mutex_unlock(&vst->output_lock);
-//        printf("pts %f time %f delay %f\n",
+        ctime = get_master_clock();
-//                frames[vfx].pts, ctime, fdelay);
+        fdelay = (vframe->pkt_pts - ctime);
-        if(fdelay > 15.0)
         if(fdelay > 15.0)
-            delay((int)fdelay/10);
-        //    return;
-        };
-#if 0
-        ctime = get_master_clock();
-        fdelay = (vst->vframe[vst->vfx].pts - ctime);
+        {
-//        while(fdelay > 0)
+            delay((int)fdelay/10);
-//        {
-//            yield();
-//            ctime = get_master_clock();
-//            fdelay = (frames[vfx].pts - ctime);
-//        }
-//        sys_time = get_tick_count();
+        };
-//        if(fdelay < 0)
-//            printf("systime %d pts %f time %f delay %f\n",
-//                    sys_time*10, frames[vfx].pts, ctime, fdelay);
         printf("pts %f time %f delay %f\n",
-                vst->vframe[vst->vfx].pts, ctime, fdelay);
+//        printf("output index: %d pts: %f pkt_pts %f pkt_dts %f\n",
-        printf("video cache %d audio cache %d\n", q_video.size/1024, q_audio.size/1024);
+//               vframe->index,vframe->pts,vframe->pkt_pts,vframe->pkt_dts);
-#endif
-        main_render->draw(main_render, &vst->vframe[vst->vfx].picture);
+        main_render->draw(main_render, vframe);
         if(main_render->win->win_state != FULLSCREEN)
         if(main_render->win->win_state != FULLSCREEN)
             prg->current = vst->vframe[vst->vfx].pts*1000;
-//        printf("current %f\n", prg->current);
+            prg->current = vframe->pkt_pts * 1000;
-            lvl->current = vst->vfx & 1 ? sound_level_1 : sound_level_0;
+            lvl->current = vframe->index & 1 ? sound_level_1 : sound_level_0;
-            send_message(&prg->ctrl, PRG_PROGRESS, 0, 0);
-            if(main_render->win->panel.layout)
-                send_message(&lvl->ctrl, MSG_PAINT, 0, 0);
-        }
-        frames_count--;
-        vst->vframe[vst->vfx].ready = 0;
+            send_message(&prg->ctrl, PRG_PROGRESS, 0, 0);
-        vst->vfx = (vst->vfx + 1) & 3;
-    }
-    else delay(1);
-#else
-    if(vst->vframe[vfx].ready == 1 )
-    {
-        ctime = get_master_clock();
-        fdelay = (vst->vrame[vst->vfx].pts - ctime);
-//            printf("pts %f time %f delay %f\n",
-//                    frames[vfx].pts, ctime, fdelay);
-        if(fdelay < 0.0 )
             if(main_render->win->panel.layout)
-            int  next_vfx;
-            fdelay = 0;
-            next_vfx = (vst->vfx+1) & 3;
-            if( vst->vrame[next_vfx].ready == 1 )
-            {
-                if(vst->vrame[next_vfx].pts <= ctime)
-                {
-                    vst->vrame[vst->vfx].ready = 0;                  // skip this frame
-                    vst->vfx = (vst->vfx + 1) & 3;
-                }
-                else
-                {
-                    if( (vst->vrame[next_vfx].pts - ctime) <
-                        ( ctime - frames[vst->vfx].pts) )
-                    {
-                        vst->vrame[vst->vfx].ready = 0;                  // skip this frame
-                        vst->vfx = (vst->vfx + 1) & 3;
-                        fdelay = (vst->vrame[next_vfx].pts - ctime);
-                    }
-                }
-            };
-        };
-        if(fdelay > 10.0)
-        {
-           int val = fdelay;
-           printf("pts %f time %f delay %d\n",
-                   vst->vrame[vst->vfx].pts, ctime, val);
-           delay(val/10);
-        };
-        ctime = get_master_clock();
-        fdelay = (vst->vrame[vst->vfx].pts - ctime);
-        printf("pts %f time %f delay %f\n",
-                vst->vrame[vst->vfx].pts, ctime, fdelay);
                 send_message(&lvl->ctrl, MSG_PAINT, 0, 0);
         main_render->draw(main_render, &vst->vrame[vfx].picture);
     init_winlib();
     MainWindow = create_window(movie_file,0,
-,10,width,height+CAPTION_HEIGHT+PANEL_HEIGHT,MainWindowProc);
+,10,vst->vCtx->width,vst->vCtx->height+CAPTION_HEIGHT+PANEL_HEIGHT,MainWindowProc);
     MainWindow->panel.prg->max = stream_duration;
     show_window(MainWindow, NORMAL);
     main_render = create_render(vst, MainWindow, HW_TEX_BLIT|HW_BIT_BLIT);
-    main_render = create_render(vst, MainWindow, HW_TEX_BLIT|HW_BIT_BLIT);
+    if( main_render == NULL)
     if( main_render == NULL)
         mutex_unlock(&vst->decoder_lock);
         printf("Cannot create render\n\r");
         return 0;
+    };
-    };
+    __sync_or_and_fetch(&threads_running,VIDEO_THREAD);
-    __sync_or_and_fetch(&threads_running,VIDEO_THREAD);
+    render_draw_client(main_render);
     return 0;
 };
-void draw_hw_picture(render_t *render, AVPicture *picture);
+void draw_hw_picture(render_t *render, vframe_t *vframe);
-void draw_sw_picture(render_t *render, AVPicture *picture);
+void draw_sw_picture(render_t *render, vframe_t *vframe);
 render_t *create_render(vst_t *vst, window_t *win, uint32_t flags)
     return;
 };
+static void render_hw_planar(render_t *render, vframe_t *vframe)
+{
+    vst_t *vst = render->vst;
+    planar_t *planar = vframe->planar;
-void draw_hw_picture(render_t *render, AVPicture *picture)
+    if(vframe->is_hw_pic != 0 && vframe->format != AV_PIX_FMT_NONE)
+    {
+        mutex_lock(&render->vst->gpu_lock);
+        pxBlitPlanar(planar, render->rcvideo.l,
+                    CAPTION_HEIGHT+render->rcvideo.t,
+                    render->rcvideo.r, render->rcvideo.b,0,0);
+        mutex_unlock(&render->vst->gpu_lock);
+    }
+};
+void draw_hw_picture(render_t *render, vframe_t *vframe)
+{
     AVPicture *picture;
     int       dst_width;
     int       dst_height;
     bitmap_t *bitmap;
     uint8_t  *bitmap_data;
     uint32_t  bitmap_pitch;
     uint8_t  *data[4];
     int       linesize[4];
+    enum AVPixelFormat format;
-    enum AVPixelFormat format;
+    vst_t *vst = render->vst;
     if(render->win->win_state == MINIMIZED ||
        render->win->win_state == ROLLED)
         dst_width  = render->rcvideo.r;
         dst_height = render->rcvideo.b;
     };
+    if(vst->hwdec)
+    {
+        render_hw_planar(render, vframe);
+        return;
+    };
+    picture = &vframe->picture;
-	format = render->vst->hwdec == 0 ? render->ctx_format : AV_PIX_FMT_BGRA
+    format = render->vst->hwdec == 0 ? render->ctx_format : AV_PIX_FMT_BGRA;
-    cvt_ctx = sws_getCachedContext(cvt_ctx,
-              render->ctx_width, render->ctx_height, format,
+    cvt_ctx = sws_getCachedContext(cvt_ctx, render->ctx_width, render->ctx_height, format,
-              dst_width, dst_height, AV_PIX_FMT_BGRA,
+                                   dst_width, dst_height, AV_PIX_FMT_BGRA,
-              SWS_FAST_BILINEAR, NULL, NULL, NULL);
+                                   SWS_FAST_BILINEAR, NULL, NULL, NULL);
     if(cvt_ctx == NULL)
+    {
         printf("Cannot initialize the conversion context!\n");
         printf("Cannot lock bitmap!\n");
         return ;
+    }
-//    printf("sws_getCachedContext\n");
     data[0] = bitmap_data;
     data[1] = bitmap_data+1;
     data[2] = bitmap_data+2;
     data[3] = bitmap_data+3;
     render->target++;
     render->target&= 1;
+}
-void draw_sw_picture(render_t *render, AVPicture *picture)
+void draw_sw_picture(render_t *render, vframe_t *vframe)
+{
+    AVPicture *picture;
     uint8_t  *bitmap_data;
     uint32_t  bitmap_pitch;
     uint8_t  *data[4];
     int      linesize[4];
     if(render->win->win_state == MINIMIZED ||
        render->win->win_state == ROLLED)
+        return;
-        return;
+    picture = &vframe->picture;
     cvt_ctx = sws_getCachedContext(cvt_ctx,
               render->ctx_width, render->ctx_height,
               render->ctx_format,
         y = CAPTION_HEIGHT;
     if(player_state == PAUSE)
+    {
-         if(vst->vframe[vst->vfx].ready == 1 )
+//         if(vst->vframe[vst->vfx].ready == 1 )
-            main_render->draw(main_render, &vst->vframe[vst->vfx].picture);
+//            main_render->draw(main_render, &vst->vframe[vst->vfx].picture);
-         else
+//         else
             draw_bar(0, y, render->win_width,
                  render->rcvideo.b, 0);
+    }
     else if( player_state == STOP )
+    {

Subversion Repositories Kolibri OS

(root)/contrib/media/fplay/video.c @ 6135 – Rev 6121 → 6133