Recherche avancée

Sur d’autres sites (7247)

• Banking Data Strategies – A Primer to Zero-party, First-party, Second-party and Third-party data

  25 octobre 2024, par Daniel Crough — Banking and Financial Services, Privacy

  Banks hold some of our most sensitive information. Every transaction, loan application, and account balance tells a story about their customers’ lives. Under GDPR and banking regulations, protecting this information isn’t optional – it’s essential.

  Yet banks also need to understand how customers use their services to serve them better. The solution lies in understanding different types of banking data and how to handle each responsibly. From direct customer interactions to market research, each data source serves a specific purpose and requires its own privacy controls.

  Before diving into how banks can use each type of data effectively, let’s look into the key differences between them :

  Data Type	What It Is	Banking Example	Legal Considerations
  First-party	Data from direct customer interactions with your services	Transaction records, service usage patterns	Different legal bases apply (contract, legal obligation, legitimate interests)
  Zero-party	Information customers actively provide	Stated preferences, financial goals	Requires specific legal basis despite being voluntary ; may involve profiling
  Second-party	Data shared through formal partnerships	Insurance history from partners	Must comply with PSD2 and specific data sharing regulations
  Third-party	Data from external providers	Market analysis, demographic data	Requires due diligence on sources and specific transparency measures

  What is first-party data ?

  

  First-party data reveals how customers actually use your banking services. When someone logs into online banking, withdraws money from an ATM, or speaks with customer service, they create valuable information about real banking habits.

  This direct interaction data proves more reliable than assumptions or market research because it shows genuine customer behaviour. Banks need specific legal grounds to process this information. Basic banking services fall under contractual necessity, while fraud detection is required by law. Marketing activities need explicit customer consent. The key is being transparent with customers about what information you process and why.

  Start by collecting only what you need for each specific purpose. Store information securely and give customers clear control through privacy settings. This approach builds trust while helping meet privacy requirements under the GDPR’s data minimisation principle.

  What is zero-party data ?

  

  Zero-party data emerges when customers actively share information about their financial goals and preferences. Unlike first-party data, which comes from observing customer behaviour, zero-party data comes through direct communication. Customers might share their retirement plans, communication preferences, or feedback about services.

  Interactive tools create natural opportunities for this exchange. A retirement calculator helps customers plan their future while revealing their financial goals. Budget planners offer immediate value through personalised advice. When customers see clear benefits, they’re more likely to share their preferences.

  However, voluntary sharing doesn’t mean unrestricted use. The ICO’s guidance on purpose limitation applies even to freely shared information. Tell customers exactly how you’ll use their data, document specific reasons for collecting each piece of information, and make it simple to update or remove personal data.

  Regular reviews help ensure you still need the information customers have shared. This aligns with both GDPR requirements and customer expectations about data management. By treating voluntary information with the same care as other customer data, banks build lasting trust.

  What is second-party data ?

  

  Second-party data comes from formal partnerships between banks and trusted companies. For example, a bank might work with an insurance provider to better understand shared customers’ financial needs.

  These partnerships need careful planning to protect customer privacy. The ICO’s Data Sharing Code provides clear guidelines : both organisations must agree on what data they’ll share, how they’ll protect it, and how long they’ll keep it before any sharing begins.

  Transparency builds trust in these arrangements. Tell customers about planned data sharing before it happens. Explain what information you’ll share and how it helps provide better services.

  Regular audits help ensure both partners maintain high privacy standards. Review shared data regularly to confirm it’s still necessary and properly protected. Be ready to adjust or end partnerships if privacy standards slip. Remember that your responsibility to protect customer data extends to information shared with partners.

  Successful partnerships balance improved service with diligent privacy protection. When done right, they help banks understand customer needs better while maintaining the trust that makes banking relationships work.

  What is third-party data ?

  

  Third-party data comes from external sources outside your bank and its partners. Market research firms, data analytics companies, and economic research organizations gather and sell this information to help banks understand broader market trends.

  This data helps fill knowledge gaps about the wider financial landscape. For example, third-party data might reveal shifts in consumer spending patterns across different age groups or regions. It can show how customers interact with different financial services or highlight emerging banking preferences in specific demographics.

  But third-party data needs careful evaluation before use. Since your bank didn’t collect this information directly, you must verify both its quality and compliance with privacy laws. Start by checking how providers collected their data and whether they had proper consent. Look for providers who clearly document their data sources and collection methods.

  Quality varies significantly among third-party data providers. Some key questions to consider before purchasing :

  • How recent is the data ?
  • How was it collected ?
  • What privacy protections are in place ?
  • How often is it updated ?
  • Which specific market segments does it cover ?

  Consider whether third-party data will truly add value beyond your existing information. Many banks find they can gain similar insights by analysing their first-party data more effectively. If you do use third-party data, document your reasons for using it and be transparent about your data sources.

  Creating your banking data strategy

  

  A clear data strategy helps your bank collect and use information effectively while protecting customer privacy. This matters most with first-party data – the information that comes directly from your customers’ banking activities.

  Start by understanding what data you already have. Many banks collect valuable information through everyday transactions, website visits, and customer service interactions. Review these existing data sources before adding new ones. Often, you already have the insights you need – they just need better organization.

  Map each type of data to a specific purpose. For example, transaction data might help detect fraud and improve service recommendations. Website analytics could reveal which banking features customers use most. Each data point should serve a clear business purpose while respecting customer privacy.

  Strong data quality standards support better decisions. Create processes to update customer information regularly and remove outdated records. Check data accuracy often and maintain consistent formats across your systems. These practices help ensure your insights reflect reality.

  Remember that strategy means choosing what not to do. You don’t need to collect every piece of data possible. Focus on information that helps you serve customers better while maintaining their privacy.

  Managing multiple data sources

  

  Banks work with many types of data – from direct customer interactions to market research. Each source serves a specific purpose, but combining them effectively requires careful planning and precise attention to regulations like GDPR and ePrivacy.

  First-party data forms your foundation. It shows how your customers actually use your services and what they need from their bank. This direct interaction data proves most valuable because it reflects real behaviour rather than assumptions. When customers check their balances, transfer money, or apply for loans, they show you exactly how they use banking services.

  Zero-party data adds context to these interactions. When customers share their financial goals or preferences directly, they help you understand the “why” behind their actions. This insight helps shape better services. For example, knowing a customer plans to buy a house helps you offer relevant savings tools or mortgage information at the right time.

  Second-party partnerships can fill specific knowledge gaps. Working with trusted partners might reveal how customers manage their broader financial lives. But only pursue partnerships when they offer clear value to customers. Always explain these relationships clearly and protect shared information carefully.

  Third-party data helps provide market context, but use it selectively. External market research can highlight broader trends or opportunities. However, this data often proves less reliable than information from direct customer interactions. Consider it a supplement to, not a replacement for, your own customer insights.

  Keep these principles in mind when combining data sources :

  • Prioritize direct customer interactions
  • Focus on information that improves services
  • Maintain consistent privacy standards across sources
  • Document where each insight comes from
  • Review regularly whether each source adds value
  • Work with privacy and data experts to ensure customer information is handled properly

  Enhance your web analytics strategy with Matomo

  

  The financial sector finds powerful and compliant web analytics increasingly valuable as it navigates data management and privacy regulations. Matomo provides a configurable privacy-centric solution that meets the requirements of banks and financial institutions.

  Matomo empowers your organisation to :

  • Collect accurate, GDPR-compliant web data
  • Integrate web analytics with your existing tools and platforms
  • Maintain full control over your analytics data
  • Gain insights without compromising user privacy

  Matomo is trusted by some of the world’s biggest banks and financial institutions. Try Matomo for free for 30 days to see how privacy-focused analytics can get you the insights you need while maintaining compliance and user trust.

• Use ffmpeg multiple h264_nvenc instances will crash occurs during release

  13 août 2024, par yang zhao

  Use FFMpeg, When multiple threads use multiple h264_nvenc instances(one instance per thread), an exception crash occurs during release(avcodec_free_context), and the final exception occurs in libnvcuvid.so.
I don't know what the reason is ? Please help, thanks.
The same problem exists : ffmpeg v5.0.1 + cuda v11.6 and ffmpeg v7.0.1 + cuda v12.2
operating system：Ubuntu 22.04.4 LTS

  


  The specific code is as follows :

  


  class NvencEncoder {
public:
    NvencEncoder() {}
    ~NvencEncoder { Close(); }
    
    bool Open() {
        auto encoder = avcodec_find_encoder_by_name("h264_nvenc");
        pCodecCtx_ = avcodec_alloc_context3(encoder);
        if (!pCodecCtx_)
            return false;

        int width = 1920;
        int height = 1080;
        int bitrate = 1000000;
        
        pCodecCtx_->codec_type = AVMEDIA_TYPE_VIDEO;
        pCodecCtx_->pix_fmt = AV_PIX_FMT_YUV420P;
        pCodecCtx_->width = width;
        pCodecCtx_->height = height;
        pCodecCtx_->bit_rate = bitrate;
        pCodecCtx_->rc_min_rate = bitrate;
        pCodecCtx_->rc_max_rate = bitrate;
        pCodecCtx_->bit_rate_tolerance = bitrate;
        pCodecCtx_->rc_buffer_size = bitrate / 2;
        pCodecCtx_->time_base = AVRational{ 1, 90000 };
        pCodecCtx_->framerate = AVRational{ 25, 1 };
        pCodecCtx_->gop_size = 50;
        pCodecCtx_->max_b_frames = 0;
        pCodecCtx_->delay = 0;
        pCodecCtx_->refs = 2;
        pCodecCtx_->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;

        av_opt_set_int(pCodecCtx_->priv_data, "gpu", 0, 0);
        av_opt_set(pCodecCtx_->priv_data, "preset", "llhp", 0);
        av_opt_set(pCodecCtx_->priv_data, "rc", "cbr", 0);
        av_opt_set(pCodecCtx_->priv_data, "profile", "main", 0);
        av_opt_set(pCodecCtx_->priv_data, "zerolatency", "1", 0);
        av_opt_set(pCodecCtx_->priv_data, "delay", "0", 0);
        av_opt_set(pCodecCtx_->priv_data, "preset", "medium", 0);

        int ret = avcodec_open2(pCodecCtx_, encoder, nullptr);
        if (ret < 0)
            return false;

        pkt_ = av_packet_alloc();
        if (!pkt_)
            return false;

        char output_mp4[] = "output.mp4";
        ret = avformat_alloc_output_context2(&avMp4Context_, NULL, "mp4", output_mp4);
        if (ret < 0)
            return false;
            
        mp4_stream_ = avformat_new_stream(avMp4Context_, nullptr);
        if (!mp4_stream_)
            return false;

        ret = avcodec_parameters_copy(mp4_stream_->codecpar, out_stream_->codecpar);
        if (ret < 0)
            return false;
            
        mp4_stream_->codecpar->codec_tag = 0;

        if (!(avMp4Context_->oformat->flags & AVFMT_NOFILE)) {
            ret = avio_open(&avMp4Context_->pb, output_mp4_.c_str(), AVIO_FLAG_WRITE);
            if (ret < 0) {
                return false;
        }
        return true;
    }

    void Close() {
        if (pCodecCtx_)
            avcodec_free_context(&pCodecCtx_); // Crash will occur in libnvcuvid.so

        if (avMp4Context_) {
            if (avMp4Context_->oformat && !(avMp4Context_->oformat->flags & AVFMT_NOFILE)) {
                avio_closep(&avMp4Context_->pb);
            }
            avformat_free_context(avMp4Context_);
            avMp4Context_ = nullptr;
        }
        
        if (pkt_)
            av_packet_free(&pkt_);
    }

    bool InputFrame(AVFrame* frame) {
        int ret = avcodec_send_frame(pEncoderVideoCodecCtx_, frame);
        if (ret < 0)
            return false;
            
        while (ret >= 0) {
            ret = avcodec_receive_packet(pEncoderVideoCodecCtx_, pkt_);
            if (ret < 0)
                break;

            if (avNotHeadWrited_) {
                ret = avformat_write_header(avMp4Context_, &opts);
                if (ret < 0) {
                    av_packet_unref(pkt_);
                    break;
                }
                avNotHeadWrited_ = false;
            }

            av_packet_rescale_ts(pkt_, pCodecCtx_->time_base, mp4_stream_->time_base);
            ret = av_write_frame(avMp4Context_, pkt_);
            if (ret < 0) {
                av_packet_unref(pkt_);
                break;
            }

            av_packet_unref(pkt_);
        }
        
        return (ret >= 0);
    }
private:
    AVPacket* pkt_ = nullptr;
    AVCodecContext* pCodecCtx_ = nullptr;
    AVFormatContext* avMp4Context_ = nullptr;
    AVStream* mp4_stream_ = nullptr;
    avNotHeadWrited_ = true;
}

uint8_t* data = nullptr; //a frame of yuv420 data
void Run(int idx);

int main() {
    //Fill a frame of yuv420 data here
    ...

    std::thread th[3];
    for (int i = 0; i < 3; i++) {
        th[i] = std::thread(Run, i);
        sleep(3);
    }

    sleep(35);

    for (int i = 0; i < 3; i++) {
        if (th[i].joinable()) {
            printf("thread %d join()\n", i);
            th[i].join();
        }
    }

    free(data);
    printf("Exit\n");
}

void Run(int idx) {
    printf("Run() thread(%d)\n", idx);
    //cudaSetDevice(0);

    auto nvenc = new NvencEncoder(ffpar, FFOutputCB);
    if (!nvenc->Open()) {
        delete nvenc;
        return;
    }

    auto avframe_ = av_frame_alloc();
    avframe_->width = 1920;
    avframe_->height = 1080;
    avframe_->format = AV_PIX_FMT_YUV420P;

    int ret = av_frame_get_buffer(avframe_, 0);
    if (ret < 0) {
        printf("av_frame_get_buffer() is error %d\n", ret);
        delete nvenc;
        av_frame_free(&avframe_);
        return;
    }

    int frame_size = 1920 * 1080;
    double one_frame_us = 1000000.0 / 25.0;
    unsigned long frame_count = 0;
    struct timeval t1, t2;
    double timeuse;

    AVRational timebase = { ffpar.timebase_num, ffpar.timebase_den };
    std::int64_t llCalcDuration = (double)AV_TIME_BASE / 25.0;
    double in_stream_timebase = av_q2d(timebase);
    std::int64_t duration = (double)llCalcDuration / (double)(in_stream_timebase * AV_TIME_BASE);
    avframe_->time_base = timebase;
    gettimeofday(&t1, NULL);

    while (frame_count < 25*30) { //30 seconds

        avframe_->pts = (double)(frame_count * llCalcDuration) / (double(in_stream_timebase * AV_TIME_BASE));
        //avframe_->duration = duration;
        frame_count++;

        ret = av_frame_make_writable(avframe_);
        if (ret < 0) {
            printf("av_frame_make_writable() is error %d\n", ret);
            break;
        }

        // copy YUV420
        memcpy(avframe_->data[0], data, frame_size);
        memcpy(avframe_->data[1], data + frame_size, frame_size / 4);
        memcpy(avframe_->data[2], data + frame_size * 5 / 4, frame_size / 4);

        ret = nvenc->InputFrame(avframe_);
        if (ret < 0) {
            printf("InputFrame() is error: %d\n", ret);
            break;
        }

        // frame rate
        gettimeofday(&t2, NULL);
        timeuse = (t2.tv_sec - t1.tv_sec) * 1000000 + (t2.tv_usec - t1.tv_usec); //us
        if (timeuse < one_frame_us) {
            usleep(one_frame_us - timeuse);
        }
        gettimeofday(&t1, NULL);
    }

    if (frame_count > 0) {
        nvenc->WriteTrailer();
    }

    printf("do Close() thread(%d)\n", idx);
    nvenc->Close();  // Crash will occur
    printf("Closed thread(%d)\n", idx);
    delete nvenc;
    av_frame_free(&avframe_);
}


  


• Need help using libavfilter for adding overlay to frames [closed]

  30 juillet 2024, par Michael Werner

  Hello gentlemen and ladies,

  


  I am working with libavfilter and I am getting crazy.

  


  On Windows 11 OS with latest libav (full build) a C/C++ app reads YUV420P frames from a frame grabber card.

  


  I want to draw a bitmap (BGR24) overlay image from file on every frame via libavfilter. First I convert the BGR24 overlay image via format filter to YUV420P. Then I feed the YUV420P frame from frame grabber and the YUV420P overlay into the overlay filter.

  


  Everything seems to be fine but when I try to get the frame out of the filter graph I always get an "Resource is temporary not available" (EAGAIN) return code, independent on how many frames I put into the graph.

  


  The frames from the frame grabber card are fine, I could encode them or write them to a .yuv file. The overlay frame looks fine too.

  


  My current initialization code looks like below. It does not report any errors or warnings but when I try to get the filtered frame out of the graph via av_buffersink_get_frame I always get an EAGAIN return code.

  


  Here is my current initialization code :

  


  int init_overlay_filter(AVFilterGraph** graph, AVFilterContext** src_ctx, AVFilterContext** overlay_src_ctx,
                        AVFilterContext** sink_ctx)
{
    AVFilterGraph* filter_graph;
    AVFilterContext* buffersrc_ctx;
    AVFilterContext* overlay_buffersrc_ctx;
    AVFilterContext* buffersink_ctx;
    AVFilterContext* overlay_ctx;
    AVFilterContext* format_ctx;
    const AVFilter *buffersrc, *buffersink, *overlay_buffersrc, *overlay_filter, *format_filter;
    int ret;

    // Create the filter graph
    filter_graph = avfilter_graph_alloc();
    if (!filter_graph)
    {
        fprintf(stderr, "Unable to create filter graph.\n");
        return AVERROR(ENOMEM);
    }

    // Create buffer source filter for main video
    buffersrc = avfilter_get_by_name("buffer");
    if (!buffersrc)
    {
        fprintf(stderr, "Unable to find buffer filter.\n");
        return AVERROR_FILTER_NOT_FOUND;
    }

    // Create buffer source filter for overlay image
    overlay_buffersrc = avfilter_get_by_name("buffer");
    if (!overlay_buffersrc)
    {
        fprintf(stderr, "Unable to find buffer filter.\n");
        return AVERROR_FILTER_NOT_FOUND;
    }

    // Create buffer sink filter
    buffersink = avfilter_get_by_name("buffersink");
    if (!buffersink)
    {
        fprintf(stderr, "Unable to find buffersink filter.\n");
        return AVERROR_FILTER_NOT_FOUND;
    }

    // Create overlay filter
    overlay_filter = avfilter_get_by_name("overlay");
    if (!overlay_filter)
    {
        fprintf(stderr, "Unable to find overlay filter.\n");
        return AVERROR_FILTER_NOT_FOUND;
    }

    // Create format filter
    format_filter = avfilter_get_by_name("format");
    if (!format_filter) 
    {
        fprintf(stderr, "Unable to find format filter.\n");
        return AVERROR_FILTER_NOT_FOUND;
    }

    // Initialize the main video buffer source
    char args[512];
    snprintf(args, sizeof(args),
             "video_size=1920x1080:pix_fmt=yuv420p:time_base=1/25:pixel_aspect=1/1");
    ret = avfilter_graph_create_filter(&buffersrc_ctx, buffersrc, "in", args, NULL, filter_graph);
    if (ret < 0)
    {
        fprintf(stderr, "Unable to create buffer source filter for main video.\n");
        return ret;
    }

    // Initialize the overlay buffer source
    snprintf(args, sizeof(args),
             "video_size=165x165:pix_fmt=bgr24:time_base=1/25:pixel_aspect=1/1");
    ret = avfilter_graph_create_filter(&overlay_buffersrc_ctx, overlay_buffersrc, "overlay_in", args, NULL,
                                       filter_graph);
    if (ret < 0)
    {
        fprintf(stderr, "Unable to create buffer source filter for overlay.\n");
        return ret;
    }

    // Initialize the format filter to convert overlay image to yuv420p
    snprintf(args, sizeof(args), "pix_fmts=yuv420p");
    ret = avfilter_graph_create_filter(&format_ctx, format_filter, "format", args, NULL, filter_graph);

    if (ret < 0) 
    {
        fprintf(stderr, "Unable to create format filter.\n");
        return ret;
    }

    // Initialize the buffer sink
    ret = avfilter_graph_create_filter(&buffersink_ctx, buffersink, "out", NULL, NULL, filter_graph);
    if (ret < 0)
    {
        fprintf(stderr, "Unable to create buffer sink filter.\n");
        return ret;
    }

    // Initialize the overlay filter
    ret = avfilter_graph_create_filter(&overlay_ctx, overlay_filter, "overlay", "W-w:H-h:enable='between(t,0,20)':format=yuv420", NULL, filter_graph);
    if (ret < 0)
    {
        fprintf(stderr, "Unable to create overlay filter.\n");
        return ret;
    }

    // Connect the filters
    ret = avfilter_link(overlay_buffersrc_ctx, 0, format_ctx, 0);

    if (ret >= 0)
    {
        ret = avfilter_link(buffersrc_ctx, 0, overlay_ctx, 0);
    }
    else
    {
        fprintf(stderr, "Unable to configure filter graph.\n");
        return ret;
    }


    if (ret >= 0) 
    {
        ret = avfilter_link(format_ctx, 0, overlay_ctx, 1);
    }
    else
    {
        fprintf(stderr, "Unable to configure filter graph.\n");
        return ret;
    }

    if (ret >= 0) 
    {
        if ((ret = avfilter_link(overlay_ctx, 0, buffersink_ctx, 0)) < 0)
        {
            fprintf(stderr, "Unable to link filter graph.\n");
            return ret;
        }
    }
    else
    {
        fprintf(stderr, "Unable to configure filter graph.\n");
        return ret;
    }

    // Configure the filter graph
    if ((ret = avfilter_graph_config(filter_graph, NULL)) < 0)
    {
        fprintf(stderr, "Unable to configure filter graph.\n");
        return ret;
    }

    *graph = filter_graph;
    *src_ctx = buffersrc_ctx;
    *overlay_src_ctx = overlay_buffersrc_ctx;
    *sink_ctx = buffersink_ctx;

    return 0;
}


  


  Feeding the filter graph is done this way :

  


  av_buffersrc_add_frame_flags(buffersrc_ctx, pFrameGrabberFrame, AV_BUFFERSRC_FLAG_KEEP_REF)
av_buffersink_get_frame(buffersink_ctx, filtered_frame)


  


  av_buffersink_get_frame returns always EAGAIN, no matter how many frames I feed into the graph. The frames (from framegrabber and the overlay frame) itself are looking fine.

  


  I did set libav logging level to maximum but I do not see any warnings or errors or helpful, related information in the log.

  


  Here the log output related to the filter configuration :

  


  [in @ 00000288ee494f40] Setting 'video_size' to value '1920x1080'
[in @ 00000288ee494f40] Setting 'pix_fmt' to value 'yuv420p'
[in @ 00000288ee494f40] Setting 'time_base' to value '1/25'
[in @ 00000288ee494f40] Setting 'pixel_aspect' to value '1/1'
[in @ 00000288ee494f40] w:1920 h:1080 pixfmt:yuv420p tb:1/25 fr:0/1 sar:1/1 csp:unknown range:unknown
[overlay_in @ 00000288ff1013c0] Setting 'video_size' to value '165x165'
[overlay_in @ 00000288ff1013c0] Setting 'pix_fmt' to value 'bgr24'
[overlay_in @ 00000288ff1013c0] Setting 'time_base' to value '1/25'
[overlay_in @ 00000288ff1013c0] Setting 'pixel_aspect' to value '1/1'
[overlay_in @ 00000288ff1013c0] w:165 h:165 pixfmt:bgr24 tb:1/25 fr:0/1 sar:1/1 csp:unknown range:unknown
[format @ 00000288ff1015c0] Setting 'pix_fmts' to value 'yuv420p'
[overlay @ 00000288ff101880] Setting 'x' to value 'W-w'
[overlay @ 00000288ff101880] Setting 'y' to value 'H-h'
[overlay @ 00000288ff101880] Setting 'enable' to value 'between(t,0,20)'
[overlay @ 00000288ff101880] Setting 'format' to value 'yuv420'
[auto_scale_0 @ 00000288ff101ec0] w:iw h:ih flags:'' interl:0
[format @ 00000288ff1015c0] auto-inserting filter 'auto_scale_0' between the filter 'overlay_in' and the filter 'format'
[auto_scale_1 @ 00000288ee4a4cc0] w:iw h:ih flags:'' interl:0
[overlay @ 00000288ff101880] auto-inserting filter 'auto_scale_1' between the filter 'format' and the filter 'overlay'
[AVFilterGraph @ 00000288ee495c80] query_formats: 5 queried, 6 merged, 6 already done, 0 delayed
[auto_scale_0 @ 00000288ff101ec0] w:165 h:165 fmt:bgr24 csp:gbr range:pc sar:1/1 -> w:165 h:165 fmt:yuv420p csp:unknown range:unknown sar:1/1 flags:0x00000004
[auto_scale_1 @ 00000288ee4a4cc0] w:165 h:165 fmt:yuv420p csp:unknown range:unknown sar:1/1 -> w:165 h:165 fmt:yuva420p csp:unknown range:unknown sar:1/1 flags:0x00000004
[overlay @ 00000288ff101880] main w:1920 h:1080 fmt:yuv420p overlay w:165 h:165 fmt:yuva420p
[overlay @ 00000288ff101880] [framesync @ 00000288ff1019a8] Selected 1/25 time base
[overlay @ 00000288ff101880] [framesync @ 00000288ff1019a8] Sync level 2