c语言编写rtp接收代码并组成h264帧，保存成h264文件

下面是一个简单的示例代码，使用C语言编写了RTP接收程序，并将接收到的数据组成H264帧并保存为H264文件：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <arpa/inet.h>

#define RTP_HEADER_SIZE 12
#define NALU_HEADER_SIZE 1

typedef struct rtp_header {
    uint8_t version:2;
    uint8_t padding:1;
    uint8_t extension:1;
    uint8_t csrc_count:4;
    uint8_t marker:1;
    uint8_t payload_type:7;
    uint16_t sequence_number;
    uint32_t timestamp;
    uint32_t ssrc;
} rtp_header_t;

int main(int argc, char *argv[]) {
    if (argc != 3) {
        printf("Usage: %s <rtp_port> <output_file>\n", argv[0]);
        return 1;
    }

    uint16_t port = atoi(argv[1]);
    char *output_file = argv[2];

    FILE *fp = fopen(output_file, "wb");
    if (fp == NULL) {
        printf("Failed to open output file!\n");
        return 1;
    }

    int sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
    if (sock < 0) {
        printf("Failed to create socket!\n");
        return 1;
    }

    struct sockaddr_in server;
    memset(&server, 0, sizeof(server));
    server.sin_family = AF_INET;
    server.sin_addr.s_addr = INADDR_ANY;
    server.sin_port = htons(port);

    if (bind(sock, (struct sockaddr *)&server, sizeof(server)) < 0) {
        printf("Failed to bind socket!\n");
        return 1;
    }

    uint8_t buffer[65536];
    rtp_header_t *rtp_header;
    uint8_t *nalu_buffer = NULL;
    int nalu_size = 0;
    int nalu_type;
    int last_nalu_end = 0;

    while (1) {
        ssize_t bytes_received = recvfrom(sock, buffer, sizeof(buffer), 0, NULL, NULL);
        if (bytes_received < RTP_HEADER_SIZE + NALU_HEADER_SIZE) {
            printf("Invalid RTP packet!\n");
            continue;
        }

        rtp_header = (rtp_header_t *)buffer;
        uint8_t *payload = buffer + RTP_HEADER_SIZE;
        int payload_size = bytes_received - RTP_HEADER_SIZE;

        if (nalu_buffer == NULL) {
            // Look for the start of an H.264 NAL unit
            for (int i = 0; i < payload_size - 4; i++) {
                if ((payload[i] == 0x00) && (payload[i+1] == 0x00) &&
                    (payload[i+2] == 0x00) && (payload[i+3] == 0x01)) {
                    // Found the start of a NAL unit
                    nalu_buffer = payload + i + 4;
                    nalu_size = payload_size - i - 4;
                    nalu_type = nalu_buffer[0] & 0x1F;
                    break;
                }
            }
        } else {
            // Look for the end of the current NAL unit
            int new_nalu_end = 0;
            for (int i = 0; i < payload_size - 4; i++) {
                if ((payload[i] == 0x00) && (payload[i+1] == 0x00) &&
                    (payload[i+2] == 0x00) && (payload[i+3] == 0x01)) {
                    // Found the start of a new NAL unit
                    new_nalu_end = i;
                    break;
                }
            }

            if (new_nalu_end > 0) {
                // This packet contains the end of the current NAL unit
                fwrite(nalu_buffer, nalu_size, 1, fp);

                // Start assembling the next NAL unit
                nalu_buffer = payload + new_nalu_end + 4;
                nalu_size = payload_size - new_nalu_end - 4;
                nalu_type = nalu_buffer[0] & 0x1F;

                // Update the last NAL unit end position
                last_nalu_end = new_nalu_end;
            } else {
                // This packet contains part of the current NAL unit
                fwrite(nalu_buffer, RTP_HEADER_SIZE + NALU_HEADER_SIZE,
                       1, fp);
                fwrite(payload, payload_size, 1, fp);
                nalu_size += payload_size;
            }
        }
    }

    fclose(fp);
    return 0;
}

该程序将从指定的RTP端口接收数据，并将接收到的数据组成H264帧并保存到指定的文件中。程序使用了一个简单的技巧来查找H264的NAL单元边界，也就是4个0字节后紧跟着一个1字节。程序的核心是一个无限循环，该循环将不断接收RTP数据包并处理它们。

请注意，这只是一个非常简单的示例程序，可能无法处理所有情况。在实际应用中，您需要考虑更多的细节和错误情况，并进行适当的错误处理和恢复。