int av_grab(AVFormatContext *s)

{

    UINT8 audio_buf[AUDIO_FIFO_SIZE];

    UINT8 audio_buf1[AUDIO_FIFO_SIZE];

    UINT8 audio_out[AUDIO_FIFO_SIZE];

    UINT8 video_buffer[1024*1024];

    char buf[256];

    short *samples;

    URLContext *audio_handle = NULL, *video_handle = NULL;

    int ret;

    AVCodecContext *enc, *first_video_enc = NULL;

    int frame_size, frame_bytes;

    int use_audio, use_video;

    int frame_rate, sample_rate, channels;

    int width, height, frame_number, i, pix_fmt = 0;

    AVOutputStream *ost_table[s->nb_streams], *ost;

    UINT8 *picture_in_buf = NULL, *picture_420p = NULL;

    int audio_fifo_size = 0, picture_size = 0;

    INT64 time_start;



    /* init output stream info */

    for(i=0;i<s->nb_streams;i++)

        ost_table[i] = NULL;



    /* output stream init */

    for(i=0;i<s->nb_streams;i++) {

        ost = av_mallocz(sizeof(AVOutputStream));

        if (!ost)

            goto fail;

        ost->index = i;

        ost->st = s->streams[i];

        ost_table[i] = ost;

    }



    use_audio = 0;

    use_video = 0;

    frame_rate = 0;

    sample_rate = 0;

    frame_size = 0;

    channels = 1;

    width = 0;

    height = 0;

    frame_number = 0;

    

    for(i=0;i<s->nb_streams;i++) {

        AVCodec *codec;



        ost = ost_table[i];

        enc = &ost->st->codec;

        codec = avcodec_find_encoder(enc->codec_id);

        if (!codec) {

            fprintf(stderr, "Unknown codec\n");

            return -1;

        }

        if (avcodec_open(enc, codec) < 0) {

            fprintf(stderr, "Incorrect encode parameters\n");

            return -1;

        }

        switch(enc->codec_type) {

        case CODEC_TYPE_AUDIO:

            use_audio = 1;

            if (enc->sample_rate > sample_rate)

                sample_rate = enc->sample_rate;

            if (enc->frame_size > frame_size)

                frame_size = enc->frame_size;

            if (enc->channels > channels)

                channels = enc->channels;

            break;

        case CODEC_TYPE_VIDEO:

            if (!first_video_enc)

                first_video_enc = enc;

            use_video = 1;

            if (enc->frame_rate > frame_rate)

                frame_rate = enc->frame_rate;

            if (enc->width > width)

                width = enc->width;

            if (enc->height > height)

                height = enc->height;

            break;

        }

    }



    /* audio */

    samples = NULL;

    if (use_audio) {

        snprintf(buf, sizeof(buf), "audio:%d,%d", sample_rate, channels);

        ret = url_open(&audio_handle, buf, URL_RDONLY);

        if (ret < 0) {

            fprintf(stderr, "Could not open audio device: disabling audio capture\n");

            use_audio = 0;

        } else {

            URLFormat f;

            /* read back exact grab parameters */

            if (url_getformat(audio_handle, &f) < 0) {

                fprintf(stderr, "could not read back video grab parameters\n");

                goto fail;

            }

            sample_rate = f.sample_rate;

            channels = f.channels;

            audio_fifo_size = ((AUDIO_FIFO_SIZE / 2) / audio_handle->packet_size) * 

                audio_handle->packet_size;

            fprintf(stderr, "Audio sampling: %d Hz, %s\n", 

                    sample_rate, channels == 2 ? "stereo" : "mono");

        }

    }

    

    /* video */

    if (use_video) {

        snprintf(buf, sizeof(buf), "video:%d,%d,%f", 

                 width, height, (float)frame_rate / FRAME_RATE_BASE);



        ret = url_open(&video_handle, buf, URL_RDONLY);

        if (ret < 0) {

            fprintf(stderr,"Could not init video 4 linux capture: disabling video capture\n");

            use_video = 0;

        } else {

            URLFormat f;

            const char *pix_fmt_str;

            /* read back exact grab parameters */

            if (url_getformat(video_handle, &f) < 0) {

                fprintf(stderr, "could not read back video grab parameters\n");

                goto fail;

            }

            width = f.width;

            height = f.height;

            pix_fmt = f.pix_fmt;

            switch(pix_fmt) {

            case PIX_FMT_YUV420P:

                pix_fmt_str = "420P";

                break;

            case PIX_FMT_YUV422:

                pix_fmt_str = "422";

                break;

            case PIX_FMT_RGB24:

                pix_fmt_str = "RGB24";

                break;

            case PIX_FMT_BGR24:

                pix_fmt_str = "BGR24";

                break;

            default:

                pix_fmt_str = "???";

                break;

            }

            picture_size = video_handle->packet_size;

            picture_in_buf = malloc(picture_size);

            if (!picture_in_buf)

                goto fail;

            /* allocate a temporary picture if not grabbing in 420P format */

            if (pix_fmt != PIX_FMT_YUV420P) {

                picture_420p = malloc((width * height * 3) / 2);

            }

            fprintf(stderr, "Video sampling: %dx%d, %s format, %0.2f fps\n", 

                    width, height, pix_fmt_str, (float)frame_rate / FRAME_RATE_BASE);

        }

    }



    if (!use_video && !use_audio) {

        fprintf(stderr,"Could not open grab devices : exiting\n");

        exit(1);

    }



    /* init built in conversion functions */

    for(i=0;i<s->nb_streams;i++) {

        ost = ost_table[i];

        enc = &ost->st->codec;

        switch(enc->codec_type) {

        case CODEC_TYPE_AUDIO:

            ost->audio_resample = 0;

            if ((enc->channels != channels ||

                 enc->sample_rate != sample_rate)) {

                ost->audio_resample = 1;

                ost->resample = audio_resample_init(enc->channels, channels,

                                                    enc->sample_rate, sample_rate);

            }

            if (fifo_init(&ost->fifo, (2 * audio_fifo_size * enc->sample_rate *

                                       enc->channels) / sample_rate))

                goto fail;

            break;

        case CODEC_TYPE_VIDEO:

            ost->video_resample = 0;

            if (enc->width != width ||

                enc->height != height) {

                UINT8 *buf;

                ost->video_resample = 1;

                buf = malloc((enc->width * enc->height * 3) / 2);

                if (!buf)

                    goto fail;

                ost->pict_tmp.data[0] = buf;

                ost->pict_tmp.data[1] = buf + enc->width * height;

                ost->pict_tmp.data[2] = ost->pict_tmp.data[1] + (enc->width * height) / 4;

                ost->pict_tmp.linesize[0] = enc->width;

                ost->pict_tmp.linesize[1] = enc->width / 2;

                ost->pict_tmp.linesize[2] = enc->width / 2;

                ost->img_resample_ctx = img_resample_init(

                                  ost->st->codec.width, ost->st->codec.height,

                                  width, height);

            }

        }

    }



    fprintf(stderr, "Press [q] to stop encoding\n");



    s->format->write_header(s);

    time_start = gettime();

    term_init();

    

    for(;;) {

        /* if 'q' pressed, exits */

        if (read_key() == 'q')

            break;



        /* read & compress audio frames */

        if (use_audio) {

            int ret, nb_samples, nb_samples_out;

            UINT8 *buftmp;



            for(;;) {

                ret = url_read(audio_handle, audio_buf, audio_fifo_size);

                if (ret <= 0)

                    break;

                /* fill each codec fifo by doing the right sample

                   rate conversion. This is not optimal because we

                   do too much work, but it is easy to do */

                nb_samples = ret / (channels * 2);

                for(i=0;i<s->nb_streams;i++) {

                    ost = ost_table[i];

                    enc = &ost->st->codec;

                    if (enc->codec_type == CODEC_TYPE_AUDIO) {

                        /* rate & stereo convertion */

                        if (!ost->audio_resample) {

                            buftmp = audio_buf;

                            nb_samples_out = nb_samples;

                        } else {

                            buftmp = audio_buf1;

                            nb_samples_out = audio_resample(ost->resample, 

                                                            (short *)buftmp, (short *)audio_buf,

                                                            nb_samples);

                        }

                        fifo_write(&ost->fifo, buftmp, nb_samples_out * enc->channels * 2, 

                                   &ost->fifo.wptr);

                    }

                }

                

                /* compress as many frame as possible with each audio codec */

                for(i=0;i<s->nb_streams;i++) {

                    ost = ost_table[i];

                    enc = &ost->st->codec;

                    if (enc->codec_type == CODEC_TYPE_AUDIO) {

                        frame_bytes = enc->frame_size * 2 * enc->channels;

                        

                        while (fifo_read(&ost->fifo, audio_buf, 

                                         frame_bytes, &ost->fifo.rptr) == 0) {

                            ret = avcodec_encode_audio(enc,

                                                       audio_out, sizeof(audio_out), 

                                                       (short *)audio_buf);

                            s->format->write_packet(s, ost->index, audio_out, ret);

                        }

                    }

                }

            }

        }



        if (use_video) {

            AVPicture *picture1, *picture2, *picture;

            AVPicture picture_tmp0, picture_tmp1;



            ret = url_read(video_handle, picture_in_buf, picture_size);

            if (ret < 0)

                break;

            

            picture2 = &picture_tmp0;

            avpicture_fill(picture2, picture_in_buf, pix_fmt, width, height);



            if (pix_fmt != PIX_FMT_YUV420P) {

                picture = &picture_tmp1;

                avpicture_fill(picture, picture_420p, 

                               PIX_FMT_YUV420P, width, height);

                img_convert(picture, PIX_FMT_YUV420P,

                            picture2, pix_fmt, 

                            width, height);

            } else {

                picture = picture2;

            }

            

            for(i=0;i<s->nb_streams;i++) {

                ost = ost_table[i];

                enc = &ost->st->codec;

                if (enc->codec_type == CODEC_TYPE_VIDEO) {

                    int n1, n2, nb;



                    /* feed each codec with its requested frame rate */

                    n1 = ((INT64)frame_number * enc->frame_rate) / frame_rate;

                    n2 = (((INT64)frame_number + 1) * enc->frame_rate) / frame_rate;

                    nb = n2 - n1;

                    if (nb > 0) {

                        /* resize the picture if needed */

                        if (ost->video_resample) {

                            picture1 = &ost->pict_tmp;

                            img_resample(ost->img_resample_ctx, 

                                         picture1, picture);

                        } else {

                            picture1 = picture;

                        }

                        ret = avcodec_encode_video(enc, video_buffer, 

                                                   sizeof(video_buffer), 

                                                   picture1);

                        s->format->write_packet(s, ost->index, video_buffer, ret);

                    }

                }

            }

            frame_number++;

        }

        

        /* write report */

        {

            char buf[1024];

            INT64 total_size;

            float ti, bitrate;

            static float last_ti;

            INT64 ti1;



            total_size = url_ftell(&s->pb);

            ti1 = gettime() - time_start;

            /* check elapsed time */

            if (recording_time && ti1 >= recording_time)

                break;



            ti = ti1 / 1000000.0;

            if (ti < 0.1)

                ti = 0.1;

            /* dispaly twice per second */

            if ((ti - last_ti) >= 0.5) {

                last_ti = ti;

                bitrate = (int)((total_size * 8) / ti / 1000.0);

                

                buf[0] = '\0';

                if (use_video) {

                    sprintf(buf + strlen(buf), "frame=%5d fps=%4.1f q=%2d ",

                            frame_number, (float)frame_number / ti, first_video_enc->quality);

                }

                

                sprintf(buf + strlen(buf), "size=%8LdkB time=%0.1f bitrate=%6.1fkbits/s", 

                        total_size / 1024, ti, bitrate);

                fprintf(stderr, "%s    \r", buf);

                fflush(stderr);

            }

        }

    }

    term_exit();



    for(i=0;i<s->nb_streams;i++) {

        ost = ost_table[i];

        enc = &ost->st->codec;

        avcodec_close(enc);

    }

    s->format->write_trailer(s);

    

    if (audio_handle)

        url_close(audio_handle);



    if (video_handle)

        url_close(video_handle);



    /* write report */

    {

        float ti, bitrate;

        INT64 total_size;



        total_size = url_ftell(&s->pb);



        ti = (gettime() - time_start) / 1000000.0;

        if (ti < 0.1)

            ti = 0.1;

        bitrate = (int)((total_size * 8) / ti / 1000.0);



        fprintf(stderr, "\033[K\nTotal time = %0.1f s, %Ld KBytes, %0.1f kbits/s\n", 

                ti, total_size / 1024, bitrate);

        if (use_video) {

            fprintf(stderr, "Total frames = %d\n", frame_number);

        }

    }



    ret = 0;

 fail1:

    if (picture_in_buf)

        free(picture_in_buf);

    if (picture_420p)

        free(picture_420p);

    for(i=0;i<s->nb_streams;i++) {

        ost = ost_table[i];

        if (ost) {

            if (ost->fifo.buffer)

                fifo_free(&ost->fifo);

            if (ost->pict_tmp.data[0])

                free(ost->pict_tmp.data[0]);

            if (ost->video_resample)

                img_resample_close(ost->img_resample_ctx);

            if (ost->audio_resample)

                audio_resample_close(ost->resample);

            free(ost);

        }

    }

    return ret;

 fail:

    ret = -ENOMEM;

    goto fail1;

}

int av_grab(AVFormatContext *s)

{

    UINT8 audio_buf[AUDIO_FIFO_SIZE];

    UINT8 audio_buf1[AUDIO_FIFO_SIZE];

    UINT8 audio_out[AUDIO_FIFO_SIZE];

    UINT8 video_buffer[1024*1024];

    char buf[256];

    short *samples;

    URLContext *audio_handle = NULL, *video_handle = NULL;

    int ret;

    AVCodecContext *enc, *first_video_enc = NULL;

    int frame_size, frame_bytes;

    int use_audio, use_video;

    int frame_rate, sample_rate, channels;

    int width, height, frame_number, i, pix_fmt = 0;

    AVOutputStream *ost_table[s->nb_streams], *ost;

    UINT8 *picture_in_buf = NULL, *picture_420p = NULL;

    int audio_fifo_size = 0, picture_size = 0;

    INT64 time_start;



    

    for(i=0;i<s->nb_streams;i++)

        ost_table[i] = NULL;



    

    for(i=0;i<s->nb_streams;i++) {

        ost = av_mallocz(sizeof(AVOutputStream));

        if (!ost)

            goto fail;

        ost->index = i;

        ost->st = s->streams[i];

        ost_table[i] = ost;

    }



    use_audio = 0;

    use_video = 0;

    frame_rate = 0;

    sample_rate = 0;

    frame_size = 0;

    channels = 1;

    width = 0;

    height = 0;

    frame_number = 0;

    

    for(i=0;i<s->nb_streams;i++) {

        AVCodec *codec;



        ost = ost_table[i];

        enc = &ost->st->codec;

        codec = avcodec_find_encoder(enc->codec_id);

        if (!codec) {

            fprintf(stderr, "Unknown codec\n");

            return -1;

        }

        if (avcodec_open(enc, codec) < 0) {

            fprintf(stderr, "Incorrect encode parameters\n");

            return -1;

        }

        switch(enc->codec_type) {

        case CODEC_TYPE_AUDIO:

            use_audio = 1;

            if (enc->sample_rate > sample_rate)

                sample_rate = enc->sample_rate;

            if (enc->frame_size > frame_size)

                frame_size = enc->frame_size;

            if (enc->channels > channels)

                channels = enc->channels;

            break;

        case CODEC_TYPE_VIDEO:

            if (!first_video_enc)

                first_video_enc = enc;

            use_video = 1;

            if (enc->frame_rate > frame_rate)

                frame_rate = enc->frame_rate;

            if (enc->width > width)

                width = enc->width;

            if (enc->height > height)

                height = enc->height;

            break;

        }

    }



    

    samples = NULL;

    if (use_audio) {

        snprintf(buf, sizeof(buf), "audio:%d,%d", sample_rate, channels);

        ret = url_open(&audio_handle, buf, URL_RDONLY);

        if (ret < 0) {

            fprintf(stderr, "Could not open audio device: disabling audio capture\n");

            use_audio = 0;

        } else {

            URLFormat f;

            

            if (url_getformat(audio_handle, &f) < 0) {

                fprintf(stderr, "could not read back video grab parameters\n");

                goto fail;

            }

            sample_rate = f.sample_rate;

            channels = f.channels;

            audio_fifo_size = ((AUDIO_FIFO_SIZE / 2) / audio_handle->packet_size) * 

                audio_handle->packet_size;

            fprintf(stderr, "Audio sampling: %d Hz, %s\n", 

                    sample_rate, channels == 2 ? "stereo" : "mono");

        }

    }

    

    

    if (use_video) {

        snprintf(buf, sizeof(buf), "video:%d,%d,%f", 

                 width, height, (float)frame_rate / FRAME_RATE_BASE);



        ret = url_open(&video_handle, buf, URL_RDONLY);

        if (ret < 0) {

            fprintf(stderr,"Could not init video 4 linux capture: disabling video capture\n");

            use_video = 0;

        } else {

            URLFormat f;

            const char *pix_fmt_str;

            

            if (url_getformat(video_handle, &f) < 0) {

                fprintf(stderr, "could not read back video grab parameters\n");

                goto fail;

            }

            width = f.width;

            height = f.height;

            pix_fmt = f.pix_fmt;

            switch(pix_fmt) {

            case PIX_FMT_YUV420P:

                pix_fmt_str = "420P";

                break;

            case PIX_FMT_YUV422:

                pix_fmt_str = "422";

                break;

            case PIX_FMT_RGB24:

                pix_fmt_str = "RGB24";

                break;

            case PIX_FMT_BGR24:

                pix_fmt_str = "BGR24";

                break;

            default:

                pix_fmt_str = "???";

                break;

            }

            picture_size = video_handle->packet_size;

            picture_in_buf = malloc(picture_size);

            if (!picture_in_buf)

                goto fail;

            

            if (pix_fmt != PIX_FMT_YUV420P) {

                picture_420p = malloc((width * height * 3) / 2);

            }

            fprintf(stderr, "Video sampling: %dx%d, %s format, %0.2f fps\n", 

                    width, height, pix_fmt_str, (float)frame_rate / FRAME_RATE_BASE);

        }

    }



    if (!use_video && !use_audio) {

        fprintf(stderr,"Could not open grab devices : exiting\n");

        exit(1);

    }



    

    for(i=0;i<s->nb_streams;i++) {

        ost = ost_table[i];

        enc = &ost->st->codec;

        switch(enc->codec_type) {

        case CODEC_TYPE_AUDIO:

            ost->audio_resample = 0;

            if ((enc->channels != channels ||

                 enc->sample_rate != sample_rate)) {

                ost->audio_resample = 1;

                ost->resample = audio_resample_init(enc->channels, channels,

                                                    enc->sample_rate, sample_rate);

            }

            if (fifo_init(&ost->fifo, (2 * audio_fifo_size * enc->sample_rate *

                                       enc->channels) / sample_rate))

                goto fail;

            break;

        case CODEC_TYPE_VIDEO:

            ost->video_resample = 0;

            if (enc->width != width ||

                enc->height != height) {

                UINT8 *buf;

                ost->video_resample = 1;

                buf = malloc((enc->width * enc->height * 3) / 2);

                if (!buf)

                    goto fail;

                ost->pict_tmp.data[0] = buf;

                ost->pict_tmp.data[1] = buf + enc->width * height;

                ost->pict_tmp.data[2] = ost->pict_tmp.data[1] + (enc->width * height) / 4;

                ost->pict_tmp.linesize[0] = enc->width;

                ost->pict_tmp.linesize[1] = enc->width / 2;

                ost->pict_tmp.linesize[2] = enc->width / 2;

                ost->img_resample_ctx = img_resample_init(

                                  ost->st->codec.width, ost->st->codec.height,

                                  width, height);

            }

        }

    }



    fprintf(stderr, "Press [q] to stop encoding\n");



    s->format->write_header(s);

    time_start = gettime();

    term_init();

    

    for(;;) {

        

        if (read_key() == 'q')

            break;



        

        if (use_audio) {

            int ret, nb_samples, nb_samples_out;

            UINT8 *buftmp;



            for(;;) {

                ret = url_read(audio_handle, audio_buf, audio_fifo_size);

                if (ret <= 0)

                    break;

                





                nb_samples = ret / (channels * 2);

                for(i=0;i<s->nb_streams;i++) {

                    ost = ost_table[i];

                    enc = &ost->st->codec;

                    if (enc->codec_type == CODEC_TYPE_AUDIO) {

                        

                        if (!ost->audio_resample) {

                            buftmp = audio_buf;

                            nb_samples_out = nb_samples;

                        } else {

                            buftmp = audio_buf1;

                            nb_samples_out = audio_resample(ost->resample, 

                                                            (short *)buftmp, (short *)audio_buf,

                                                            nb_samples);

                        }

                        fifo_write(&ost->fifo, buftmp, nb_samples_out * enc->channels * 2, 

                                   &ost->fifo.wptr);

                    }

                }

                

                

                for(i=0;i<s->nb_streams;i++) {

                    ost = ost_table[i];

                    enc = &ost->st->codec;

                    if (enc->codec_type == CODEC_TYPE_AUDIO) {

                        frame_bytes = enc->frame_size * 2 * enc->channels;

                        

                        while (fifo_read(&ost->fifo, audio_buf, 

                                         frame_bytes, &ost->fifo.rptr) == 0) {

                            ret = avcodec_encode_audio(enc,

                                                       audio_out, sizeof(audio_out), 

                                                       (short *)audio_buf);

                            s->format->write_packet(s, ost->index, audio_out, ret);

                        }

                    }

                }

            }

        }



        if (use_video) {

            AVPicture *picture1, *picture2, *picture;

            AVPicture picture_tmp0, picture_tmp1;



            ret = url_read(video_handle, picture_in_buf, picture_size);

            if (ret < 0)

                break;

            

            picture2 = &picture_tmp0;

            avpicture_fill(picture2, picture_in_buf, pix_fmt, width, height);



            if (pix_fmt != PIX_FMT_YUV420P) {

                picture = &picture_tmp1;

                avpicture_fill(picture, picture_420p, 

                               PIX_FMT_YUV420P, width, height);

                img_convert(picture, PIX_FMT_YUV420P,

                            picture2, pix_fmt, 

                            width, height);

            } else {

                picture = picture2;

            }

            

            for(i=0;i<s->nb_streams;i++) {

                ost = ost_table[i];

                enc = &ost->st->codec;

                if (enc->codec_type == CODEC_TYPE_VIDEO) {

                    int n1, n2, nb;



                    

                    n1 = ((INT64)frame_number * enc->frame_rate) / frame_rate;

                    n2 = (((INT64)frame_number + 1) * enc->frame_rate) / frame_rate;

                    nb = n2 - n1;

                    if (nb > 0) {

                        

                        if (ost->video_resample) {

                            picture1 = &ost->pict_tmp;

                            img_resample(ost->img_resample_ctx, 

                                         picture1, picture);

                        } else {

                            picture1 = picture;

                        }

                        ret = avcodec_encode_video(enc, video_buffer, 

                                                   sizeof(video_buffer), 

                                                   picture1);

                        s->format->write_packet(s, ost->index, video_buffer, ret);

                    }

                }

            }

            frame_number++;

        }

        

        

        {

            char buf[1024];

            INT64 total_size;

            float ti, bitrate;

            static float last_ti;

            INT64 ti1;



            total_size = url_ftell(&s->pb);

            ti1 = gettime() - time_start;

            

            if (recording_time && ti1 >= recording_time)

                break;



            ti = ti1 / 1000000.0;

            if (ti < 0.1)

                ti = 0.1;

            

            if ((ti - last_ti) >= 0.5) {

                last_ti = ti;

                bitrate = (int)((total_size * 8) / ti / 1000.0);

                

                buf[0] = '\0';

                if (use_video) {

                    sprintf(buf + strlen(buf), "frame=%5d fps=%4.1f q=%2d ",

                            frame_number, (float)frame_number / ti, first_video_enc->quality);

                }

                

                sprintf(buf + strlen(buf), "size=%8LdkB time=%0.1f bitrate=%6.1fkbits/s", 

                        total_size / 1024, ti, bitrate);

                fprintf(stderr, "%s    \r", buf);

                fflush(stderr);

            }

        }

    }

    term_exit();



    for(i=0;i<s->nb_streams;i++) {

        ost = ost_table[i];

        enc = &ost->st->codec;

        avcodec_close(enc);

    }

    s->format->write_trailer(s);

    

    if (audio_handle)

        url_close(audio_handle);



    if (video_handle)

        url_close(video_handle);



    

    {

        float ti, bitrate;

        INT64 total_size;



        total_size = url_ftell(&s->pb);



        ti = (gettime() - time_start) / 1000000.0;

        if (ti < 0.1)

            ti = 0.1;

        bitrate = (int)((total_size * 8) / ti / 1000.0);



        fprintf(stderr, "\033[K\nTotal time = %0.1f s, %Ld KBytes, %0.1f kbits/s\n", 

                ti, total_size / 1024, bitrate);

        if (use_video) {

            fprintf(stderr, "Total frames = %d\n", frame_number);

        }

    }



    ret = 0;

 fail1:

    if (picture_in_buf)

        free(picture_in_buf);

    if (picture_420p)

        free(picture_420p);

    for(i=0;i<s->nb_streams;i++) {

        ost = ost_table[i];

        if (ost) {

            if (ost->fifo.buffer)

                fifo_free(&ost->fifo);

            if (ost->pict_tmp.data[0])

                free(ost->pict_tmp.data[0]);

            if (ost->video_resample)

                img_resample_close(ost->img_resample_ctx);

            if (ost->audio_resample)

                audio_resample_close(ost->resample);

            free(ost);

        }

    }

    return ret;

 fail:

    ret = -ENOMEM;

    goto fail1;

}

int FUNC_0(AVFormatContext *VAR_0)

{

    UINT8 audio_buf[AUDIO_FIFO_SIZE];

    UINT8 audio_buf1[AUDIO_FIFO_SIZE];

    UINT8 audio_out[AUDIO_FIFO_SIZE];

    UINT8 video_buffer[1024*1024];

    char VAR_21[256];

    short *VAR_2;

    URLContext *audio_handle = NULL, *video_handle = NULL;

    int VAR_19;

    AVCodecContext *enc, *first_video_enc = NULL;

    int VAR_4, VAR_5;

    int VAR_6, VAR_7;

    int VAR_8, VAR_9, VAR_10;

    int VAR_11, VAR_12, VAR_13, VAR_14, VAR_15 = 0;

    AVOutputStream *ost_table[VAR_0->nb_streams], *ost;

    UINT8 *picture_in_buf = NULL, *picture_420p = NULL;

    int VAR_16 = 0, VAR_17 = 0;

    INT64 time_start;



    

    for(VAR_14=0;VAR_14<VAR_0->nb_streams;VAR_14++)

        ost_table[VAR_14] = NULL;



    

    for(VAR_14=0;VAR_14<VAR_0->nb_streams;VAR_14++) {

        ost = av_mallocz(sizeof(AVOutputStream));

        if (!ost)

            goto fail;

        ost->index = VAR_14;

        ost->st = VAR_0->streams[VAR_14];

        ost_table[VAR_14] = ost;

    }



    VAR_6 = 0;

    VAR_7 = 0;

    VAR_8 = 0;

    VAR_9 = 0;

    VAR_4 = 0;

    VAR_10 = 1;

    VAR_11 = 0;

    VAR_12 = 0;

    VAR_13 = 0;

    

    for(VAR_14=0;VAR_14<VAR_0->nb_streams;VAR_14++) {

        AVCodec *codec;



        ost = ost_table[VAR_14];

        enc = &ost->st->codec;

        codec = avcodec_find_encoder(enc->codec_id);

        if (!codec) {

            fprintf(stderr, "Unknown codec\n");

            return -1;

        }

        if (avcodec_open(enc, codec) < 0) {

            fprintf(stderr, "Incorrect encode parameters\n");

            return -1;

        }

        switch(enc->codec_type) {

        case CODEC_TYPE_AUDIO:

            VAR_6 = 1;

            if (enc->VAR_9 > VAR_9)

                VAR_9 = enc->VAR_9;

            if (enc->VAR_4 > VAR_4)

                VAR_4 = enc->VAR_4;

            if (enc->VAR_10 > VAR_10)

                VAR_10 = enc->VAR_10;

            break;

        case CODEC_TYPE_VIDEO:

            if (!first_video_enc)

                first_video_enc = enc;

            VAR_7 = 1;

            if (enc->VAR_8 > VAR_8)

                VAR_8 = enc->VAR_8;

            if (enc->VAR_11 > VAR_11)

                VAR_11 = enc->VAR_11;

            if (enc->VAR_12 > VAR_12)

                VAR_12 = enc->VAR_12;

            break;

        }

    }



    

    VAR_2 = NULL;

    if (VAR_6) {

        snprintf(VAR_21, sizeof(VAR_21), "audio:%d,%d", VAR_9, VAR_10);

        VAR_19 = url_open(&audio_handle, VAR_21, URL_RDONLY);

        if (VAR_19 < 0) {

            fprintf(stderr, "Could not open audio device: disabling audio capture\n");

            VAR_6 = 0;

        } else {

            URLFormat f;

            

            if (url_getformat(audio_handle, &f) < 0) {

                fprintf(stderr, "could not read back video grab parameters\n");

                goto fail;

            }

            VAR_9 = f.VAR_9;

            VAR_10 = f.VAR_10;

            VAR_16 = ((AUDIO_FIFO_SIZE / 2) / audio_handle->packet_size) * 

                audio_handle->packet_size;

            fprintf(stderr, "Audio sampling: %d Hz, %VAR_0\n", 

                    VAR_9, VAR_10 == 2 ? "stereo" : "mono");

        }

    }

    

    

    if (VAR_7) {

        snprintf(VAR_21, sizeof(VAR_21), "video:%d,%d,%f", 

                 VAR_11, VAR_12, (float)VAR_8 / FRAME_RATE_BASE);



        VAR_19 = url_open(&video_handle, VAR_21, URL_RDONLY);

        if (VAR_19 < 0) {

            fprintf(stderr,"Could not init video 4 linux capture: disabling video capture\n");

            VAR_7 = 0;

        } else {

            URLFormat f;

            const char *VAR_18;

            

            if (url_getformat(video_handle, &f) < 0) {

                fprintf(stderr, "could not read back video grab parameters\n");

                goto fail;

            }

            VAR_11 = f.VAR_11;

            VAR_12 = f.VAR_12;

            VAR_15 = f.VAR_15;

            switch(VAR_15) {

            case PIX_FMT_YUV420P:

                VAR_18 = "420P";

                break;

            case PIX_FMT_YUV422:

                VAR_18 = "422";

                break;

            case PIX_FMT_RGB24:

                VAR_18 = "RGB24";

                break;

            case PIX_FMT_BGR24:

                VAR_18 = "BGR24";

                break;

            default:

                VAR_18 = "???";

                break;

            }

            VAR_17 = video_handle->packet_size;

            picture_in_buf = malloc(VAR_17);

            if (!picture_in_buf)

                goto fail;

            

            if (VAR_15 != PIX_FMT_YUV420P) {

                picture_420p = malloc((VAR_11 * VAR_12 * 3) / 2);

            }

            fprintf(stderr, "Video sampling: %dx%d, %VAR_0 format, %0.2f fps\n", 

                    VAR_11, VAR_12, VAR_18, (float)VAR_8 / FRAME_RATE_BASE);

        }

    }



    if (!VAR_7 && !VAR_6) {

        fprintf(stderr,"Could not open grab devices : exiting\n");

        exit(1);

    }



    

    for(VAR_14=0;VAR_14<VAR_0->nb_streams;VAR_14++) {

        ost = ost_table[VAR_14];

        enc = &ost->st->codec;

        switch(enc->codec_type) {

        case CODEC_TYPE_AUDIO:

            ost->audio_resample = 0;

            if ((enc->VAR_10 != VAR_10 ||

                 enc->VAR_9 != VAR_9)) {

                ost->audio_resample = 1;

                ost->resample = audio_resample_init(enc->VAR_10, VAR_10,

                                                    enc->VAR_9, VAR_9);

            }

            if (fifo_init(&ost->fifo, (2 * VAR_16 * enc->VAR_9 *

                                       enc->VAR_10) / VAR_9))

                goto fail;

            break;

        case CODEC_TYPE_VIDEO:

            ost->video_resample = 0;

            if (enc->VAR_11 != VAR_11 ||

                enc->VAR_12 != VAR_12) {

                UINT8 *VAR_21;

                ost->video_resample = 1;

                VAR_21 = malloc((enc->VAR_11 * enc->VAR_12 * 3) / 2);

                if (!VAR_21)

                    goto fail;

                ost->pict_tmp.data[0] = VAR_21;

                ost->pict_tmp.data[1] = VAR_21 + enc->VAR_11 * VAR_12;

                ost->pict_tmp.data[2] = ost->pict_tmp.data[1] + (enc->VAR_11 * VAR_12) / 4;

                ost->pict_tmp.linesize[0] = enc->VAR_11;

                ost->pict_tmp.linesize[1] = enc->VAR_11 / 2;

                ost->pict_tmp.linesize[2] = enc->VAR_11 / 2;

                ost->img_resample_ctx = img_resample_init(

                                  ost->st->codec.VAR_11, ost->st->codec.VAR_12,

                                  VAR_11, VAR_12);

            }

        }

    }



    fprintf(stderr, "Press [q] to stop encoding\n");



    VAR_0->format->write_header(VAR_0);

    time_start = gettime();

    term_init();

    

    for(;;) {

        

        if (read_key() == 'q')

            break;



        

        if (VAR_6) {

            int VAR_19, VAR_19, VAR_20;

            UINT8 *buftmp;



            for(;;) {

                VAR_19 = url_read(audio_handle, audio_buf, VAR_16);

                if (VAR_19 <= 0)

                    break;

                





                VAR_19 = VAR_19 / (VAR_10 * 2);

                for(VAR_14=0;VAR_14<VAR_0->nb_streams;VAR_14++) {

                    ost = ost_table[VAR_14];

                    enc = &ost->st->codec;

                    if (enc->codec_type == CODEC_TYPE_AUDIO) {

                        

                        if (!ost->audio_resample) {

                            buftmp = audio_buf;

                            VAR_20 = VAR_19;

                        } else {

                            buftmp = audio_buf1;

                            VAR_20 = audio_resample(ost->resample, 

                                                            (short *)buftmp, (short *)audio_buf,

                                                            VAR_19);

                        }

                        fifo_write(&ost->fifo, buftmp, VAR_20 * enc->VAR_10 * 2, 

                                   &ost->fifo.wptr);

                    }

                }

                

                

                for(VAR_14=0;VAR_14<VAR_0->nb_streams;VAR_14++) {

                    ost = ost_table[VAR_14];

                    enc = &ost->st->codec;

                    if (enc->codec_type == CODEC_TYPE_AUDIO) {

                        VAR_5 = enc->VAR_4 * 2 * enc->VAR_10;

                        

                        while (fifo_read(&ost->fifo, audio_buf, 

                                         VAR_5, &ost->fifo.rptr) == 0) {

                            VAR_19 = avcodec_encode_audio(enc,

                                                       audio_out, sizeof(audio_out), 

                                                       (short *)audio_buf);

                            VAR_0->format->write_packet(VAR_0, ost->index, audio_out, VAR_19);

                        }

                    }

                }

            }

        }



        if (VAR_7) {

            AVPicture *picture1, *picture2, *picture;

            AVPicture picture_tmp0, picture_tmp1;



            VAR_19 = url_read(video_handle, picture_in_buf, VAR_17);

            if (VAR_19 < 0)

                break;

            

            picture2 = &picture_tmp0;

            avpicture_fill(picture2, picture_in_buf, VAR_15, VAR_11, VAR_12);



            if (VAR_15 != PIX_FMT_YUV420P) {

                picture = &picture_tmp1;

                avpicture_fill(picture, picture_420p, 

                               PIX_FMT_YUV420P, VAR_11, VAR_12);

                img_convert(picture, PIX_FMT_YUV420P,

                            picture2, VAR_15, 

                            VAR_11, VAR_12);

            } else {

                picture = picture2;

            }

            

            for(VAR_14=0;VAR_14<VAR_0->nb_streams;VAR_14++) {

                ost = ost_table[VAR_14];

                enc = &ost->st->codec;

                if (enc->codec_type == CODEC_TYPE_VIDEO) {

                    int n1, n2, nb;



                    

                    n1 = ((INT64)VAR_13 * enc->VAR_8) / VAR_8;

                    n2 = (((INT64)VAR_13 + 1) * enc->VAR_8) / VAR_8;

                    nb = n2 - n1;

                    if (nb > 0) {

                        

                        if (ost->video_resample) {

                            picture1 = &ost->pict_tmp;

                            img_resample(ost->img_resample_ctx, 

                                         picture1, picture);

                        } else {

                            picture1 = picture;

                        }

                        VAR_19 = avcodec_encode_video(enc, video_buffer, 

                                                   sizeof(video_buffer), 

                                                   picture1);

                        VAR_0->format->write_packet(VAR_0, ost->index, video_buffer, VAR_19);

                    }

                }

            }

            VAR_13++;

        }

        

        

        {

            char VAR_21[1024];

            INT64 total_size;

            float VAR_24, VAR_24;

            static float VAR_23;

            INT64 ti1;



            total_size = url_ftell(&VAR_0->pb);

            ti1 = gettime() - time_start;

            

            if (recording_time && ti1 >= recording_time)

                break;



            VAR_24 = ti1 / 1000000.0;

            if (VAR_24 < 0.1)

                VAR_24 = 0.1;

            

            if ((VAR_24 - VAR_23) >= 0.5) {

                VAR_23 = VAR_24;

                VAR_24 = (int)((total_size * 8) / VAR_24 / 1000.0);

                

                VAR_21[0] = '\0';

                if (VAR_7) {

                    sprintf(VAR_21 + strlen(VAR_21), "frame=%5d fps=%4.1f q=%2d ",

                            VAR_13, (float)VAR_13 / VAR_24, first_video_enc->quality);

                }

                

                sprintf(VAR_21 + strlen(VAR_21), "size=%8LdkB time=%0.1f VAR_24=%6.1fkbits/VAR_0", 

                        total_size / 1024, VAR_24, VAR_24);

                fprintf(stderr, "%VAR_0    \r", VAR_21);

                fflush(stderr);

            }

        }

    }

    term_exit();



    for(VAR_14=0;VAR_14<VAR_0->nb_streams;VAR_14++) {

        ost = ost_table[VAR_14];

        enc = &ost->st->codec;

        avcodec_close(enc);

    }

    VAR_0->format->write_trailer(VAR_0);

    

    if (audio_handle)

        url_close(audio_handle);



    if (video_handle)

        url_close(video_handle);



    

    {

        float VAR_24, VAR_24;

        INT64 total_size;



        total_size = url_ftell(&VAR_0->pb);



        VAR_24 = (gettime() - time_start) / 1000000.0;

        if (VAR_24 < 0.1)

            VAR_24 = 0.1;

        VAR_24 = (int)((total_size * 8) / VAR_24 / 1000.0);



        fprintf(stderr, "\033[K\nTotal time = %0.1f VAR_0, %Ld KBytes, %0.1f kbits/VAR_0\n", 

                VAR_24, total_size / 1024, VAR_24);

        if (VAR_7) {

            fprintf(stderr, "Total frames = %d\n", VAR_13);

        }

    }



    VAR_19 = 0;

 fail1:

    if (picture_in_buf)

        free(picture_in_buf);

    if (picture_420p)

        free(picture_420p);

    for(VAR_14=0;VAR_14<VAR_0->nb_streams;VAR_14++) {

        ost = ost_table[VAR_14];

        if (ost) {

            if (ost->fifo.buffer)

                fifo_free(&ost->fifo);

            if (ost->pict_tmp.data[0])

                free(ost->pict_tmp.data[0]);

            if (ost->video_resample)

                img_resample_close(ost->img_resample_ctx);

            if (ost->audio_resample)

                audio_resample_close(ost->resample);

            free(ost);

        }

    }

    return VAR_19;

 fail:

    VAR_19 = -ENOMEM;

    goto fail1;

}

int FUNC_0(AVFormatContext *VAR_0)
{ UINT8 audio_buf[AUDIO_FIFO_SIZE]; UINT8 audio_buf1[AUDIO_FIFO_SIZE]; UINT8 audio_out[AUDIO_FIFO_SIZE]; UINT8 video_buffer[1024*1024]; char VAR_21[256]; short *VAR_2; URLContext *audio_handle = NULL, *video_handle = NULL; int VAR_19; AVCodecContext *enc, *first_video_enc = NULL; int VAR_4, VAR_5; int VAR_6, VAR_7; int VAR_8, VAR_9, VAR_10; int VAR_11, VAR_12, VAR_13, VAR_14, VAR_15 = 0; AVOutputStream *ost_table[VAR_0->nb_streams], *ost; UINT8 *picture_in_buf = NULL, *picture_420p = NULL; int VAR_16 = 0, VAR_17 = 0; INT64 time_start; for(VAR_14=0;VAR_14<VAR_0->nb_streams;VAR_14++) ost_table[VAR_14] = NULL; for(VAR_14=0;VAR_14<VAR_0->nb_streams;VAR_14++) { ost = av_mallocz(sizeof(AVOutputStream)); if (!ost)
goto fail; ost->index = VAR_14; ost->st = VAR_0->streams[VAR_14]; ost_table[VAR_14] = ost; } VAR_6 = 0; VAR_7 = 0; VAR_8 = 0; VAR_9 = 0; VAR_4 = 0; VAR_10 = 1; VAR_11 = 0; VAR_12 = 0; VAR_13 = 0; for(VAR_14=0;VAR_14<VAR_0->nb_streams;VAR_14++) { AVCodec *codec; ost = ost_table[VAR_14]; enc = &ost->st->codec; codec = avcodec_find_encoder(enc->codec_id); if (!codec) { fprintf(stderr, "Unknown codec\n"); return -1; } if (avcodec_open(enc, codec) < 0) { fprintf(stderr, "Incorrect encode parameters\n"); return -1; } switch(enc->codec_type) { case CODEC_TYPE_AUDIO:
VAR_6 = 1; if (enc->VAR_9 > VAR_9)
VAR_9 = enc->VAR_9; if (enc->VAR_4 > VAR_4)
VAR_4 = enc->VAR_4; if (enc->VAR_10 > VAR_10)
VAR_10 = enc->VAR_10; break; case CODEC_TYPE_VIDEO:
if (!first_video_enc)
first_video_enc = enc; VAR_7 = 1; if (enc->VAR_8 > VAR_8)
VAR_8 = enc->VAR_8; if (enc->VAR_11 > VAR_11)
VAR_11 = enc->VAR_11; if (enc->VAR_12 > VAR_12)
VAR_12 = enc->VAR_12; break; } } VAR_2 = NULL; if (VAR_6) { snprintf(VAR_21, sizeof(VAR_21), "audio:%d,%d", VAR_9, VAR_10); VAR_19 = url_open(&audio_handle, VAR_21, URL_RDONLY); if (VAR_19 < 0) { fprintf(stderr, "Could not open audio device: disabling audio capture\n"); VAR_6 = 0; } else { URLFormat f; if (url_getformat(audio_handle, &f) < 0) { fprintf(stderr, "could not read back video grab parameters\n"); goto fail; } VAR_9 = f.VAR_9; VAR_10 = f.VAR_10; VAR_16 = ((AUDIO_FIFO_SIZE / 2) / audio_handle->packet_size) *
audio_handle->packet_size; fprintf(stderr, "Audio sampling: %d Hz, %VAR_0\n",
VAR_9, VAR_10 == 2 ? "stereo" : "mono"); } } if (VAR_7) { snprintf(VAR_21, sizeof(VAR_21), "video:%d,%d,%f",
VAR_11, VAR_12, (float)VAR_8 / FRAME_RATE_BASE); VAR_19 = url_open(&video_handle, VAR_21, URL_RDONLY); if (VAR_19 < 0) { fprintf(stderr,"Could not init video 4 linux capture: disabling video capture\n"); VAR_7 = 0; } else { URLFormat f; const char *VAR_18; if (url_getformat(video_handle, &f) < 0) { fprintf(stderr, "could not read back video grab parameters\n"); goto fail; } VAR_11 = f.VAR_11; VAR_12 = f.VAR_12; VAR_15 = f.VAR_15; switch(VAR_15) { case PIX_FMT_YUV420P:
VAR_18 = "420P"; break; case PIX_FMT_YUV422:
VAR_18 = "422"; break; case PIX_FMT_RGB24:
VAR_18 = "RGB24"; break; case PIX_FMT_BGR24:
VAR_18 = "BGR24"; break; default:
VAR_18 = "???"; break; } VAR_17 = video_handle->packet_size; picture_in_buf = malloc(VAR_17); if (!picture_in_buf)
goto fail; if (VAR_15 != PIX_FMT_YUV420P) { picture_420p = malloc((VAR_11 * VAR_12 * 3) / 2); } fprintf(stderr, "Video sampling: %dx%d, %VAR_0 format, %0.2f fps\n",
VAR_11, VAR_12, VAR_18, (float)VAR_8 / FRAME_RATE_BASE); } } if (!VAR_7 && !VAR_6) { fprintf(stderr,"Could not open grab devices : exiting\n"); exit(1); } for(VAR_14=0;VAR_14<VAR_0->nb_streams;VAR_14++) { ost = ost_table[VAR_14]; enc = &ost->st->codec; switch(enc->codec_type) { case CODEC_TYPE_AUDIO:
ost->audio_resample = 0; if ((enc->VAR_10 != VAR_10 ||
enc->VAR_9 != VAR_9)) { ost->audio_resample = 1; ost->resample = audio_resample_init(enc->VAR_10, VAR_10,
enc->VAR_9, VAR_9); } if (fifo_init(&ost->fifo, (2 * VAR_16 * enc->VAR_9 *
enc->VAR_10) / VAR_9))
goto fail; break; case CODEC_TYPE_VIDEO:
ost->video_resample = 0; if (enc->VAR_11 != VAR_11 ||
enc->VAR_12 != VAR_12) { UINT8 *VAR_21; ost->video_resample = 1; VAR_21 = malloc((enc->VAR_11 * enc->VAR_12 * 3) / 2); if (!VAR_21)
goto fail; ost->pict_tmp.data[0] = VAR_21; ost->pict_tmp.data[1] = VAR_21 + enc->VAR_11 * VAR_12; ost->pict_tmp.data[2] = ost->pict_tmp.data[1] + (enc->VAR_11 * VAR_12) / 4; ost->pict_tmp.linesize[0] = enc->VAR_11; ost->pict_tmp.linesize[1] = enc->VAR_11 / 2; ost->pict_tmp.linesize[2] = enc->VAR_11 / 2; ost->img_resample_ctx = img_resample_init(
ost->st->codec.VAR_11, ost->st->codec.VAR_12,
VAR_11, VAR_12); } } } fprintf(stderr, "Press [q] to stop encoding\n"); VAR_0->format->write_header(VAR_0); time_start = gettime(); term_init(); for(;;) { if (read_key() == 'q')
break; if (VAR_6) { int VAR_19, VAR_19, VAR_20; UINT8 *buftmp; for(;;) { VAR_19 = url_read(audio_handle, audio_buf, VAR_16); if (VAR_19 <= 0)
break; VAR_19 = VAR_19 / (VAR_10 * 2); for(VAR_14=0;VAR_14<VAR_0->nb_streams;VAR_14++) { ost = ost_table[VAR_14]; enc = &ost->st->codec; if (enc->codec_type == CODEC_TYPE_AUDIO) { if (!ost->audio_resample) { buftmp = audio_buf; VAR_20 = VAR_19; } else { buftmp = audio_buf1; VAR_20 = audio_resample(ost->resample,
(short *)buftmp, (short *)audio_buf,
VAR_19); } fifo_write(&ost->fifo, buftmp, VAR_20 * enc->VAR_10 * 2,
&ost->fifo.wptr); } } for(VAR_14=0;VAR_14<VAR_0->nb_streams;VAR_14++) { ost = ost_table[VAR_14]; enc = &ost->st->codec; if (enc->codec_type == CODEC_TYPE_AUDIO) { VAR_5 = enc->VAR_4 * 2 * enc->VAR_10; while (fifo_read(&ost->fifo, audio_buf,
VAR_5, &ost->fifo.rptr) == 0) { VAR_19 = avcodec_encode_audio(enc,
audio_out, sizeof(audio_out),
(short *)audio_buf); VAR_0->format->write_packet(VAR_0, ost->index, audio_out, VAR_19); } } } } } if (VAR_7) { AVPicture *picture1, *picture2, *picture; AVPicture picture_tmp0, picture_tmp1; VAR_19 = url_read(video_handle, picture_in_buf, VAR_17); if (VAR_19 < 0)
break; picture2 = &picture_tmp0; avpicture_fill(picture2, picture_in_buf, VAR_15, VAR_11, VAR_12); if (VAR_15 != PIX_FMT_YUV420P) { picture = &picture_tmp1; avpicture_fill(picture, picture_420p,
PIX_FMT_YUV420P, VAR_11, VAR_12); img_convert(picture, PIX_FMT_YUV420P,
picture2, VAR_15,
VAR_11, VAR_12); } else { picture = picture2; } for(VAR_14=0;VAR_14<VAR_0->nb_streams;VAR_14++) { ost = ost_table[VAR_14]; enc = &ost->st->codec; if (enc->codec_type == CODEC_TYPE_VIDEO) { int n1, n2, nb; n1 = ((INT64)VAR_13 * enc->VAR_8) / VAR_8; n2 = (((INT64)VAR_13 + 1) * enc->VAR_8) / VAR_8; nb = n2 - n1; if (nb > 0) { if (ost->video_resample) { picture1 = &ost->pict_tmp; img_resample(ost->img_resample_ctx,
picture1, picture); } else { picture1 = picture; } VAR_19 = avcodec_encode_video(enc, video_buffer,
sizeof(video_buffer),
picture1); VAR_0->format->write_packet(VAR_0, ost->index, video_buffer, VAR_19); } } } VAR_13++; } { char VAR_21[1024]; INT64 total_size; float VAR_24, VAR_24; static float VAR_23; INT64 ti1; total_size = url_ftell(&VAR_0->pb); ti1 = gettime() - time_start; if (recording_time && ti1 >= recording_time)
break; VAR_24 = ti1 / 1000000.0; if (VAR_24 < 0.1)
VAR_24 = 0.1; if ((VAR_24 - VAR_23) >= 0.5) { VAR_23 = VAR_24; VAR_24 = (int)((total_size * 8) / VAR_24 / 1000.0); VAR_21[0] = '\0'; if (VAR_7) { sprintf(VAR_21 + strlen(VAR_21), "frame=%5d fps=%4.1f q=%2d ",
VAR_13, (float)VAR_13 / VAR_24, first_video_enc->quality); } sprintf(VAR_21 + strlen(VAR_21), "size=%8LdkB time=%0.1f VAR_24=%6.1fkbits/VAR_0",
total_size / 1024, VAR_24, VAR_24); fprintf(stderr, "%VAR_0    \r", VAR_21); fflush(stderr); } } } term_exit(); for(VAR_14=0;VAR_14<VAR_0->nb_streams;VAR_14++) { ost = ost_table[VAR_14]; enc = &ost->st->codec; avcodec_close(enc); } VAR_0->format->write_trailer(VAR_0); if (audio_handle)
url_close(audio_handle); if (video_handle)
url_close(video_handle); { float VAR_24, VAR_24; INT64 total_size; total_size = url_ftell(&VAR_0->pb); VAR_24 = (gettime() - time_start) / 1000000.0; if (VAR_24 < 0.1)
VAR_24 = 0.1; VAR_24 = (int)((total_size * 8) / VAR_24 / 1000.0); fprintf(stderr, "\033[K\nTotal time = %0.1f VAR_0, %Ld KBytes, %0.1f kbits/VAR_0\n",
VAR_24, total_size / 1024, VAR_24); if (VAR_7) { fprintf(stderr, "Total frames = %d\n", VAR_13); } } VAR_19 = 0; fail1:
if (picture_in_buf)
free(picture_in_buf); if (picture_420p)
free(picture_420p); for(VAR_14=0;VAR_14<VAR_0->nb_streams;VAR_14++) { ost = ost_table[VAR_14]; if (ost) { if (ost->fifo.buffer)
fifo_free(&ost->fifo); if (ost->pict_tmp.data[0])
free(ost->pict_tmp.data[0]); if (ost->video_resample)
img_resample_close(ost->img_resample_ctx); if (ost->audio_resample)
audio_resample_close(ost->resample); free(ost); } } return VAR_19; fail:
VAR_19 = -ENOMEM; goto fail1; }