Data interaction between avframe\avpacket and itself in ffmpeg

In the use of ffmpeg Sometimes our own data structures, such as yuv Data or compressed H264 Data wants to be converted to ffmpeg Medium AVFrame perhaps AVPacket Structure , How to turn it ？
This is in ffmpg Of libavcodec Of v4l2_buffers.h/.c There are very good cases in .
Let's talk about my personal understanding .

1、 Here's my yuv Data structures 
struct Private;
struct MyYUV{
    
uint8_t *data[8];
int planes[8];
int length;
int width;
int height;
int pix_fmt;
int off_set;
Private *private;
}

1、yuv The data goes to AVFrame Packet data ：

void int MyYUV_2_Avframe(AVFrame *frame, MyYUV *in){
    
int i , ret;
frame->format = in ->pix_fmt; 
for (i = 0; i < in->length; i++) {
    
   ret = buf_to_bufref(in, i, &frame->buf[i]);
   if (ret) return ret;
   frame->linesize[i] = in->planes[i];
   frame->data[i] = frame->buf[i]->data;
    }
}

// This function mainly creates AVBufferRef , And point the relevant data to its internal pointer 
int buf_to_bufref(MyYUV *in, int plane, AVBufferRef **buf){
    
   int ret;
   if (plane >= in->num_planes)
        return AVERROR(EINVAL);

    /* even though most encoders return 0 in data_offset encoding vp8 does require this value */
    // among my_free_buffer It's a callback function , To release yuv data .
    *buf = av_buffer_create((char *)in->data[plane] + in->off_set,
                            in->data[plane] * in->height, my_free_buffer, in, 0);
    if (!*buf)
        return AVERROR(ENOMEM);
    return ret;
}
// The next two functions are ffmpeg Internal function buffer.c In file 
// It can be found through observation , There is no storage space for application data inside , Just created a AVBufferRef  And a AVBuffer , Then let the data pointer copy directly .
static AVBufferRef *buffer_create(AVBuffer *buf, uint8_t *data, size_t size,
                                  void (*free)(void *opaque, uint8_t *data),
                                  void *opaque, int flags)
{
    
    AVBufferRef *ref = NULL;

    buf->data     = data;
    buf->size     = size;
    buf->free     = free ? free : av_buffer_default_free;
    buf->opaque   = opaque;

    atomic_init(&buf->refcount, 1);

    buf->flags = flags;

    ref = av_mallocz(sizeof(*ref));
    if (!ref)
        return NULL;

    ref->buffer = buf;
    ref->data   = data;
    ref->size   = size;

    return ref;
}

AVBufferRef *av_buffer_create(uint8_t *data, size_t size,
                              void (*free)(void *opaque, uint8_t *data),
                              void *opaque, int flags)
{
    
    AVBufferRef *ret;
    AVBuffer *buf = av_mallocz(sizeof(*buf));
    if (!buf)
        return NULL;

    ret = buffer_create(buf, data, size, free, opaque, flags);
    if (!ret) {
    
        av_free(buf);
        return NULL;
    }
    return ret;
}

2、h264 The data goes to AVPacket Packet data ：

int mybuf_to_avpkt(AVPacket *pkt, MyYUV *avbuf)
{
    
    int ret;

    av_packet_unref(pkt);
    // Special note ffmpeg Use of references in , Here is the same as the previous case .
    ret = buf_to_bufref(avbuf, 0, &pkt->buf);
    if (ret)
        return ret;

    pkt->size = avbuf->planes[0] * height;
    pkt->data = pkt->buf->data;

    if (avbuf->buf.flags & BUF_FLAG_KEYFRAME)
        pkt->flags |= AV_PKT_FLAG_KEY;

    if (avbuf->buf.flags & BUF_FLAG_ERROR) {
    
        av_log(logger(avbuf), AV_LOG_ERROR, "%s driver encode error\n", avbuf->context->name);
        pkt->flags |= AV_PKT_FLAG_CORRUPT;
    }

    pkt->dts = pkt->pts = buf_get_pts(avbuf);

    return 0;
}

On the contrary, it is very simple, simple data copy .