1387 lines
36 KiB
C
1387 lines
36 KiB
C
|
|
/*
|
|
* Copyright (c) 2024 Amlogic, Inc. All rights reserved.
|
|
*
|
|
* This source code is subject to the terms and conditions defined in the
|
|
* file 'LICENSE' which is part of this source code package.
|
|
*
|
|
* Description:
|
|
*/
|
|
|
|
/**************************************************
|
|
* example based on amcodec
|
|
**************************************************/
|
|
#include <sys/types.h>
|
|
#include <sys/stat.h>
|
|
#include <fcntl.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <stdbool.h>
|
|
#include <signal.h>
|
|
#include <errno.h>
|
|
#include <stdbool.h>
|
|
#include <ctype.h>
|
|
#include <semaphore.h>
|
|
#include <unistd.h>
|
|
#include <getopt.h>
|
|
#include <stdint.h>
|
|
|
|
#include "vcodec_utils.h"
|
|
#include "v4l2_dec.h"
|
|
|
|
//#define DEBUG_FRAME
|
|
|
|
#define BUFFER_SIZE (1024*1024*4)
|
|
#define AML_VP9_HEADER_SIZE 16
|
|
#define VP9_IVF_HEAD_SIZE 32
|
|
#define VP9_IVF_FRAME_HEAD_SIZE 12
|
|
#define STREAM_MODE_WRITE_BLOCK_SIZE (64 * 1024)
|
|
#define is_ivf_type(type) \
|
|
(type == VFORMAT_AV1)
|
|
|
|
static int video_type;
|
|
FILE* fp = NULL;
|
|
static char *filename;
|
|
static char *frame_size_file;
|
|
static char *pix_name;
|
|
int g_dw_mode = 16;
|
|
int g_dump_dec_info_num = 5;
|
|
static sem_t wait_for_end;
|
|
int g_log_level = 0;
|
|
int g_output_flag = 0;
|
|
int g_nv21 = 1;
|
|
|
|
enum v4lplayer_mem_type g_mem_type = V4LPLAYER_MEM_TYPE_MMAP;
|
|
enum v4lplayer_play_mode g_play_mode = V4LPLAYER_FRAME_MODE;
|
|
static int write_es_data(const uint8_t *data, int size)
|
|
{
|
|
v4l2_dec_write_es(data, size);
|
|
v4l2_dec_frame_done();
|
|
return size;
|
|
}
|
|
|
|
int send_buffer_to_device(char *buffer, int Readlen)
|
|
{
|
|
int isize = 0;
|
|
int ret;
|
|
|
|
do {
|
|
ret = write_es_data((const uint8_t *)(buffer + isize), (Readlen - isize));
|
|
if (ret < 0) {
|
|
if (errno != EAGAIN) {
|
|
debug_print(DEBUG_ERROR, "write data failed, errno %d\n", errno);
|
|
return -1;
|
|
} else {
|
|
continue;
|
|
}
|
|
} else {
|
|
isize += ret;
|
|
debug_print(DEBUG_FRAME, "write %d, cur isize %d\n", ret, isize);
|
|
}
|
|
debug_print(DEBUG_FRAME, "ret %d, isize %d\n", ret, isize);
|
|
} while (isize < Readlen);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/***************** ivf parser *******************/
|
|
#define MAX_SIZE 0x200000
|
|
|
|
/*!\brief OBU types. */
|
|
typedef enum ATTRIBUTE_PACKED {
|
|
OBU_SEQUENCE_HEADER = 1,
|
|
OBU_TEMPORAL_DELIMITER = 2,
|
|
OBU_FRAME_HEADER = 3,
|
|
OBU_TILE_GROUP = 4,
|
|
OBU_METADATA = 5,
|
|
OBU_FRAME = 6,
|
|
OBU_REDUNDANT_FRAME_HEADER = 7,
|
|
OBU_TILE_LIST = 8,
|
|
OBU_PADDING = 15,
|
|
} OBU_TYPE;
|
|
|
|
/*!\brief OBU metadata types. */
|
|
typedef enum {
|
|
OBU_METADATA_TYPE_RESERVED_0 = 0,
|
|
OBU_METADATA_TYPE_HDR_CLL = 1,
|
|
OBU_METADATA_TYPE_HDR_MDCV = 2,
|
|
OBU_METADATA_TYPE_SCALABILITY = 3,
|
|
OBU_METADATA_TYPE_ITUT_T35 = 4,
|
|
OBU_METADATA_TYPE_TIMECODE = 5,
|
|
} OBU_METADATA_TYPE;
|
|
|
|
typedef struct {
|
|
size_t size; // Size (1 or 2 bytes) of the OBU header (including the
|
|
// optional OBU extension header) in the bitstream.
|
|
OBU_TYPE type;
|
|
int has_size_field;
|
|
int has_extension;
|
|
// The following fields come from the OBU extension header and therefore are
|
|
// only used if has_extension is true.
|
|
int temporal_layer_id;
|
|
int spatial_layer_id;
|
|
} ObuHeader;
|
|
|
|
static const size_t kMaximumLeb128Size = 8;
|
|
static const uint8_t kLeb128ByteMask = 0x7f; // Binary: 01111111
|
|
|
|
// Disallow values larger than 32-bits to ensure consistent behavior on 32 and
|
|
// 64 bit targets: value is typically used to determine buffer allocation size
|
|
// when decoded.
|
|
static const uint64_t kMaximumLeb128Value = UINT32_MAX;
|
|
|
|
size_t uleb_size_in_bytes(uint64_t value) {
|
|
size_t size = 0;
|
|
do {
|
|
++size;
|
|
} while ((value >>= 7) != 0);
|
|
return size;
|
|
}
|
|
|
|
int uleb_decode(const uint8_t *buffer, size_t available, uint64_t *value, size_t *length)
|
|
{
|
|
uint32_t i = 0;
|
|
if (buffer && value) {
|
|
*value = 0;
|
|
for (i = 0; i < kMaximumLeb128Size && i < available; ++i) {
|
|
const uint8_t decoded_byte = *(buffer + i) & kLeb128ByteMask;
|
|
*value |= ((uint64_t)decoded_byte) << (i * 7);
|
|
if ((*(buffer + i) >> 7) == 0) {
|
|
if (length) {
|
|
*length = i + 1;
|
|
}
|
|
|
|
// Fail on values larger than 32-bits to ensure consistent behavior on
|
|
// 32 and 64 bit targets: value is typically used to determine buffer
|
|
// allocation size.
|
|
if (*value > UINT32_MAX) return -1;
|
|
|
|
return 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
// If we get here, either the buffer/value pointers were invalid,
|
|
// or we ran over the available space
|
|
return -1;
|
|
}
|
|
|
|
int uleb_encode(uint64_t value, size_t available, uint8_t *coded_value, size_t *coded_size)
|
|
{
|
|
uint32_t i = 0;
|
|
const size_t leb_size = uleb_size_in_bytes(value);
|
|
if (value > kMaximumLeb128Value || leb_size > kMaximumLeb128Size ||
|
|
leb_size > available || !coded_value || !coded_size) {
|
|
return -1;
|
|
}
|
|
|
|
for (i = 0; i < leb_size; ++i) {
|
|
uint8_t byte = value & 0x7f;
|
|
value >>= 7;
|
|
|
|
if (value != 0) byte |= 0x80; // Signal that more bytes follow.
|
|
|
|
*(coded_value + i) = byte;
|
|
}
|
|
|
|
*coded_size = leb_size;
|
|
return 0;
|
|
}
|
|
|
|
int uleb_encode_fixed_size(uint64_t value, size_t available,
|
|
size_t pad_to_size, uint8_t *coded_value, size_t *coded_size)
|
|
{
|
|
uint32_t i;
|
|
if (value > kMaximumLeb128Value || !coded_value || !coded_size ||
|
|
available < pad_to_size || pad_to_size > kMaximumLeb128Size) {
|
|
return -1;
|
|
}
|
|
const uint64_t limit = 1ULL << (7 * pad_to_size);
|
|
if (value >= limit) {
|
|
// Can't encode 'value' within 'pad_to_size' bytes
|
|
return -1;
|
|
}
|
|
|
|
for (i = 0; i < pad_to_size; ++i) {
|
|
uint8_t byte = value & 0x7f;
|
|
value >>= 7;
|
|
|
|
if (i < pad_to_size - 1) byte |= 0x80; // Signal that more bytes follow.
|
|
|
|
*(coded_value + i) = byte;
|
|
}
|
|
|
|
*coded_size = pad_to_size;
|
|
return 0;
|
|
}
|
|
|
|
// Returns 1 when OBU type is valid, and 0 otherwise.
|
|
static int valid_obu_type(int obu_type)
|
|
{
|
|
int valid_type = 0;
|
|
switch (obu_type) {
|
|
case OBU_SEQUENCE_HEADER:
|
|
case OBU_TEMPORAL_DELIMITER:
|
|
case OBU_FRAME_HEADER:
|
|
case OBU_TILE_GROUP:
|
|
case OBU_METADATA:
|
|
case OBU_FRAME:
|
|
case OBU_REDUNDANT_FRAME_HEADER:
|
|
case OBU_TILE_LIST:
|
|
case OBU_PADDING: valid_type = 1; break;
|
|
default: break;
|
|
}
|
|
return valid_type;
|
|
}
|
|
|
|
char obu_type_name[16][32] = {
|
|
"UNKNOWN",
|
|
"OBU_SEQUENCE_HEADER",
|
|
"OBU_TEMPORAL_DELIMITER",
|
|
"OBU_FRAME_HEADER",
|
|
"OBU_TILE_GROUP",
|
|
"OBU_METADATA",
|
|
"OBU_FRAME",
|
|
"OBU_REDUNDANT_FRAME_HEADER",
|
|
"OBU_TILE_LIST",
|
|
"UNKNOWN",
|
|
"UNKNOWN",
|
|
"UNKNOWN",
|
|
"UNKNOWN",
|
|
"UNKNOWN",
|
|
"UNKNOWN",
|
|
"OBU_PADDING"
|
|
};
|
|
|
|
char meta_type_name[6][32] = {
|
|
"OBU_METADATA_TYPE_RESERVED_0",
|
|
"OBU_METADATA_TYPE_HDR_CLL",
|
|
"OBU_METADATA_TYPE_HDR_MDCV",
|
|
"OBU_METADATA_TYPE_SCALABILITY",
|
|
"OBU_METADATA_TYPE_ITUT_T35",
|
|
"OBU_METADATA_TYPE_TIMECODE"
|
|
};
|
|
|
|
struct read_bit_buffer {
|
|
const uint8_t *bit_buffer;
|
|
const uint8_t *bit_buffer_end;
|
|
uint32_t bit_offset;
|
|
};
|
|
|
|
typedef struct DataBuffer {
|
|
const uint8_t *data;
|
|
size_t size;
|
|
} DataBuffer;
|
|
|
|
static int rb_read_bit(struct read_bit_buffer *rb)
|
|
{
|
|
const uint32_t off = rb->bit_offset;
|
|
const uint32_t p = off >> 3;
|
|
const int q = 7 - (int)(off & 0x7);
|
|
if (rb->bit_buffer + p < rb->bit_buffer_end) {
|
|
const int bit = (rb->bit_buffer[p] >> q) & 1;
|
|
rb->bit_offset = off + 1;
|
|
return bit;
|
|
}
|
|
else {
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
static int rb_read_literal(struct read_bit_buffer *rb, int bits)
|
|
{
|
|
int value = 0, bit;
|
|
for (bit = bits - 1; bit >= 0; bit--) value |= rb_read_bit(rb) << bit;
|
|
return value;
|
|
}
|
|
|
|
static int read_obu_size(const uint8_t *data,
|
|
size_t bytes_available,
|
|
size_t *const obu_size,
|
|
size_t *const length_field_size)
|
|
{
|
|
uint64_t u_obu_size = 0;
|
|
if (uleb_decode(data, bytes_available, &u_obu_size, length_field_size) != 0) {
|
|
return -1;
|
|
}
|
|
|
|
if (u_obu_size > UINT32_MAX) return -1;
|
|
*obu_size = (size_t)u_obu_size;
|
|
return 0;
|
|
}
|
|
|
|
// Parses OBU header and stores values in 'header'.
|
|
static int read_obu_header(struct read_bit_buffer *rb, int is_annexb, ObuHeader *header)
|
|
{
|
|
if (!rb || !header) return -1;
|
|
|
|
//const ptrdiff_t bit_buffer_byte_length = rb->bit_buffer_end - rb->bit_buffer;
|
|
const long int bit_buffer_byte_length = rb->bit_buffer_end - rb->bit_buffer;
|
|
if (bit_buffer_byte_length < 1) return -1;
|
|
|
|
header->size = 1;
|
|
|
|
if (rb_read_bit(rb) != 0) {
|
|
// Forbidden bit. Must not be set.
|
|
return -1;
|
|
}
|
|
|
|
header->type = (OBU_TYPE)rb_read_literal(rb, 4);
|
|
|
|
if (!valid_obu_type(header->type))
|
|
return -1;
|
|
|
|
header->has_extension = rb_read_bit(rb);
|
|
header->has_size_field = rb_read_bit(rb);
|
|
|
|
if (!header->has_size_field && !is_annexb) {
|
|
// section 5 obu streams must have obu_size field set.
|
|
return -1;
|
|
}
|
|
|
|
if (rb_read_bit(rb) != 0) {
|
|
// obu_reserved_1bit must be set to 0.
|
|
return -1;
|
|
}
|
|
|
|
if (header->has_extension) {
|
|
if (bit_buffer_byte_length == 1) return -1;
|
|
|
|
header->size += 1;
|
|
header->temporal_layer_id = rb_read_literal(rb, 3);
|
|
header->spatial_layer_id = rb_read_literal(rb, 2);
|
|
if (rb_read_literal(rb, 3) != 0) {
|
|
// extension_header_reserved_3bits must be set to 0.
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int read_obu_header_and_size(const uint8_t *data,
|
|
size_t bytes_available, int is_annexb, ObuHeader *obu_header,
|
|
size_t *const payload_size, size_t *const bytes_read)
|
|
{
|
|
size_t length_field_size_obu = 0;
|
|
size_t length_field_size_payload = 0;
|
|
size_t obu_size = 0;
|
|
int status = 0;
|
|
|
|
if (is_annexb) {
|
|
// Size field comes before the OBU header, and includes the OBU header
|
|
status =
|
|
read_obu_size(data, bytes_available, &obu_size, &length_field_size_obu);
|
|
|
|
if (status != 0) return status;
|
|
}
|
|
|
|
struct read_bit_buffer rb = { data + length_field_size_obu,
|
|
data + bytes_available, 0};
|
|
|
|
status = read_obu_header(&rb, is_annexb, obu_header);
|
|
if (status != 0) return status;
|
|
|
|
if (!obu_header->has_size_field) {
|
|
// Derive the payload size from the data we've already read
|
|
if (obu_size < obu_header->size) return -1;
|
|
|
|
*payload_size = obu_size - obu_header->size;
|
|
} else {
|
|
// Size field comes after the OBU header, and is just the payload size
|
|
status = read_obu_size(
|
|
data + length_field_size_obu + obu_header->size,
|
|
bytes_available - length_field_size_obu - obu_header->size,
|
|
payload_size, &length_field_size_payload);
|
|
if (status != 0) return status;
|
|
}
|
|
|
|
*bytes_read =
|
|
length_field_size_obu + obu_header->size + length_field_size_payload;
|
|
return 0;
|
|
}
|
|
|
|
int parser_frame(int is_annexb, uint8_t *data, const uint8_t *data_end,
|
|
uint8_t *dst_data, uint32_t *frame_len, uint8_t *meta_buf, uint32_t *meta_len)
|
|
{
|
|
int frame_decoding_finished = 0;
|
|
uint32_t obu_size = 0;
|
|
ObuHeader obu_header;
|
|
memset(&obu_header, 0, sizeof(obu_header));
|
|
int seen_frame_header = 0;
|
|
//int next_start_tile = 0;
|
|
DataBuffer obu_size_hdr;
|
|
uint8_t header[20] = {
|
|
0x00, 0x00, 0x01, 0x54,
|
|
0xFF, 0xFF, 0xFE, 0xAB,
|
|
0x00, 0x00, 0x00, 0x01,
|
|
0x41, 0x4D, 0x4C, 0x56,
|
|
0xD0, 0x82, 0x80, 0x00
|
|
};
|
|
uint8_t *p = NULL;
|
|
uint32_t rpu_size = 0;
|
|
|
|
// decode frame as a series of OBUs
|
|
while (!frame_decoding_finished) {
|
|
// struct read_bit_buffer rb;
|
|
size_t payload_size = 0;
|
|
size_t header_size = 0;
|
|
size_t bytes_read = 0;
|
|
size_t bytes_written = 0;
|
|
const size_t bytes_available = data_end - data;
|
|
unsigned int i;
|
|
OBU_METADATA_TYPE meta_type;
|
|
uint64_t type;
|
|
|
|
if (bytes_available == 0 && !seen_frame_header) {
|
|
break;
|
|
}
|
|
|
|
int status = read_obu_header_and_size(data, bytes_available, is_annexb,
|
|
&obu_header, &payload_size, &bytes_read);
|
|
|
|
if (status != 0) {
|
|
return -1;
|
|
}
|
|
|
|
// Record obu size header information.
|
|
obu_size_hdr.data = data + obu_header.size;
|
|
obu_size_hdr.size = bytes_read - obu_header.size;
|
|
|
|
// Note: read_obu_header_and_size() takes care of checking that this
|
|
// doesn't cause 'data' to advance past 'data_end'.
|
|
|
|
if ((size_t)(data_end - data - bytes_read) < payload_size) {
|
|
return -1;
|
|
}
|
|
#ifdef DEBUG_FRAME
|
|
debug_print(DEBUG_FRAME, "\tobu %s len %zu+%zu\n", obu_type_name[obu_header.type], bytes_read, payload_size);
|
|
#endif
|
|
obu_size = bytes_read + payload_size + 4;
|
|
|
|
if (!is_annexb) {
|
|
obu_size = bytes_read + payload_size + 4;
|
|
header_size = 20;
|
|
uleb_encode_fixed_size(obu_size, 4, 4, header + 16, &bytes_written);
|
|
}
|
|
else {
|
|
obu_size = bytes_read + payload_size;
|
|
header_size = 16;
|
|
}
|
|
header[0] = ((obu_size + 4) >> 24) & 0xff;
|
|
header[1] = ((obu_size + 4) >> 16) & 0xff;
|
|
header[2] = ((obu_size + 4) >> 8) & 0xff;
|
|
header[3] = ((obu_size + 4) >> 0) & 0xff;
|
|
header[4] = header[0] ^ 0xff;
|
|
header[5] = header[1] ^ 0xff;
|
|
header[6] = header[2] ^ 0xff;
|
|
header[7] = header[3] ^ 0xff;
|
|
memcpy(dst_data, header, header_size);
|
|
dst_data += header_size;
|
|
memcpy(dst_data, data, bytes_read + payload_size);
|
|
dst_data += bytes_read + payload_size;
|
|
|
|
data += bytes_read;
|
|
*frame_len += 20 + bytes_read + payload_size;
|
|
|
|
switch (obu_header.type) {
|
|
case OBU_TEMPORAL_DELIMITER:
|
|
seen_frame_header = 0;
|
|
//next_start_tile = 0;
|
|
break;
|
|
case OBU_SEQUENCE_HEADER:
|
|
// The sequence header should not change in the middle of a frame.
|
|
if (seen_frame_header) {
|
|
return -1;
|
|
}
|
|
break;
|
|
case OBU_FRAME_HEADER:
|
|
if (data_end == data + payload_size) {
|
|
frame_decoding_finished = 1;
|
|
}
|
|
else {
|
|
seen_frame_header = 1;
|
|
}
|
|
break;
|
|
case OBU_REDUNDANT_FRAME_HEADER:
|
|
case OBU_FRAME:
|
|
if (obu_header.type == OBU_REDUNDANT_FRAME_HEADER) {
|
|
if (!seen_frame_header) {
|
|
return -1;
|
|
}
|
|
} else {
|
|
// OBU_FRAME_HEADER or OBU_FRAME.
|
|
if (seen_frame_header) {
|
|
return -1;
|
|
}
|
|
}
|
|
if (obu_header.type == OBU_FRAME) {
|
|
if (data_end == data + payload_size) {
|
|
frame_decoding_finished = 1;
|
|
seen_frame_header = 0;
|
|
}
|
|
}
|
|
break;
|
|
case OBU_TILE_GROUP:
|
|
if (!seen_frame_header) {
|
|
return -1;
|
|
}
|
|
if (data + payload_size == data_end)
|
|
frame_decoding_finished = 1;
|
|
if (frame_decoding_finished)
|
|
seen_frame_header = 0;
|
|
break;
|
|
case OBU_METADATA:
|
|
uleb_decode(data, 8, &type, &bytes_read);
|
|
if (type < 6)
|
|
meta_type = type;
|
|
else
|
|
meta_type = 0;
|
|
p = data + bytes_read;
|
|
debug_print(DEBUG_FRAME, "\t meta type %s %zu+%zu\n", meta_type_name[type], bytes_read, payload_size - bytes_read);
|
|
|
|
if (meta_type == OBU_METADATA_TYPE_ITUT_T35) {
|
|
#if 0 /* for dumping original obu payload */
|
|
for (i = 0; i < payload_size - bytes_read; i++) {
|
|
debug_print(DEBUG_FRAME, "%02x ", p[i]);
|
|
if (i % 16 == 15) debug_print(DEBUG_FRAME, "\n");
|
|
}
|
|
if (i % 16 != 0) debug_print(DEBUG_FRAME, "\n");
|
|
#endif
|
|
if ((p[0] == 0xb5) /* country code */
|
|
&& ((p[1] == 0x00) && (p[2] == 0x3b)) /* terminal_provider_code */
|
|
&& ((p[3] == 0x00) && (p[4] == 0x00) && (p[5] == 0x08) && (p[6] == 0x00))) { /* terminal_provider_oriented_code */
|
|
meta_buf[0] = meta_buf[1] = meta_buf[2] = 0;
|
|
meta_buf[3] = 0x01; meta_buf[4] = 0x19;
|
|
|
|
if (p[11] & 0x10) {
|
|
rpu_size = 0x100;
|
|
rpu_size |= (p[11] & 0x0f) << 4;
|
|
rpu_size |= (p[12] >> 4) & 0x0f;
|
|
if (p[12] & 0x08) {
|
|
debug_print(DEBUG_FRAME, "\t meta rpu in obu exceed 512 bytes\n");
|
|
break;
|
|
}
|
|
for (i = 0; i < rpu_size; i++) {
|
|
meta_buf[5 + i] = (p[12 + i] & 0x07) << 5;
|
|
meta_buf[5 + i] |= (p[13 + i] >> 3) & 0x1f;
|
|
}
|
|
rpu_size += 5;
|
|
} else {
|
|
rpu_size = (p[10] & 0x1f) << 3;
|
|
rpu_size |= (p[11] >> 5) & 0x07;
|
|
for (i = 0; i < rpu_size; i++) {
|
|
meta_buf[5 + i] = (p[11 + i] & 0x0f) << 4;
|
|
meta_buf[5 + i] |= (p[12 + i] >> 4) & 0x0f;
|
|
}
|
|
rpu_size += 5;
|
|
}
|
|
*meta_len = rpu_size;
|
|
}
|
|
} else if (meta_type == OBU_METADATA_TYPE_HDR_CLL) {
|
|
debug_print(DEBUG_FRAME, "\t\t hdr10 cll:\n");
|
|
debug_print(DEBUG_FRAME, "\t\t max_cll = %x\n", (p[0] << 8) | p[1]);
|
|
debug_print(DEBUG_FRAME, "\t\t max_fall = %x\n", (p[2] << 8) | p[3]);
|
|
} else if (meta_type == OBU_METADATA_TYPE_HDR_MDCV) {
|
|
debug_print(DEBUG_FRAME, "\t\t hdr10 primaries[r,g,b] = \n");
|
|
for (i = 0; i < 3; i++) {
|
|
printf("\t\t %x, %x\n", (p[i * 4] << 8) | p[i * 4 + 1],
|
|
(p[i * 4 + 2] << 8) | p[i * 4 + 3]);
|
|
}
|
|
debug_print(DEBUG_FRAME, "\t\t white point = %x, %x\n", (p[12] << 8) | p[13], (p[14] << 8) | p[15]);
|
|
debug_print(DEBUG_FRAME, "\t\t maxl = %x\n", (p[16] << 24) | (p[17] << 16) | (p[18] << 8) | p[19]);
|
|
debug_print(DEBUG_FRAME, "\t\t minl = %x\n", (p[20] << 24) | (p[21] << 16) | (p[22] << 8) | p[23]);
|
|
}
|
|
break;
|
|
case OBU_TILE_LIST:
|
|
break;
|
|
case OBU_PADDING:
|
|
break;
|
|
default:
|
|
// Skip unrecognized OBUs
|
|
break;
|
|
}
|
|
|
|
data += payload_size;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
bool is_video_file_type_ivf(FILE *fp, char *buffer)
|
|
{
|
|
if (fp && is_ivf_type(video_type)) {
|
|
fread(buffer, 1, 4, fp);
|
|
fseek(fp, 0, SEEK_SET);
|
|
if ((buffer[0] == 0x44) &&
|
|
(buffer[1] == 0x4B) &&
|
|
(buffer[2] == 0x49) &&
|
|
(buffer[3] == 0x46))
|
|
return true;
|
|
} else if (is_ivf_type(video_type)) {
|
|
if ((buffer[0] == 0x44) &&
|
|
(buffer[1] == 0x4B) &&
|
|
(buffer[2] == 0x49) &&
|
|
(buffer[3] == 0x46))
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
int av1_ivf_write_dat(FILE *src_fp, uint8_t *src_buffer)
|
|
{
|
|
int frame_count = 0;
|
|
unsigned int src_frame_size = 0;
|
|
unsigned int dst_frame_size = 0;
|
|
unsigned int meta_size = 0;
|
|
uint8_t *dst_buffer = NULL;
|
|
uint8_t *meta_buffer = NULL;
|
|
int process_count = -1;
|
|
unsigned int *p_size;
|
|
|
|
meta_buffer = calloc(1, 1024);
|
|
if (!meta_buffer) {
|
|
debug_print(DEBUG_ERROR, "fail to alloc meta buf\n");
|
|
return -1;
|
|
}
|
|
if (fread(src_buffer, 1, 32, src_fp) != 32) {
|
|
debug_print(DEBUG_ERROR, "read input file error!\n");
|
|
free(meta_buffer);
|
|
return -1;
|
|
}
|
|
p_size = (unsigned int *)(src_buffer + 24);
|
|
process_count = *p_size;
|
|
debug_print(DEBUG_DEF, "av1 ivf frame number = %d\n", process_count);
|
|
/*
|
|
* no frame count limit
|
|
*/
|
|
/* coverity[tainted_data:SUPPRESS] */
|
|
while (frame_count < process_count) {
|
|
if (fread(src_buffer, 1, 12, src_fp) != 12) {
|
|
printf("end of file!\n");
|
|
break;
|
|
}
|
|
p_size = (unsigned int *)src_buffer;
|
|
src_frame_size = *p_size;
|
|
if (src_frame_size > BUFFER_SIZE)
|
|
src_frame_size = BUFFER_SIZE;
|
|
|
|
#ifdef DEBUG_FRAME
|
|
debug_print(DEBUG_FRAME, "frame %d, size %d\n", frame_count, src_frame_size);
|
|
#endif
|
|
if (fread(src_buffer, 1, src_frame_size, src_fp) != src_frame_size) {
|
|
debug_print(DEBUG_ERROR, "read input file error %d!\n", src_frame_size);
|
|
break;
|
|
}
|
|
|
|
dst_buffer = calloc(1, src_frame_size + 4096);
|
|
if (!dst_buffer) {
|
|
debug_print(DEBUG_ERROR, "failed to alloc frame buf\n");
|
|
break;
|
|
}
|
|
dst_frame_size = 0;
|
|
meta_size = 0;
|
|
|
|
parser_frame(0, src_buffer, src_buffer + src_frame_size, dst_buffer, &dst_frame_size, meta_buffer, &meta_size);
|
|
if (dst_frame_size) {
|
|
#ifdef DEBUG_FRAME
|
|
debug_print(DEBUG_FRAME, "\toutput len=%d\n", dst_frame_size);
|
|
#endif
|
|
if (send_buffer_to_device((char *)dst_buffer, dst_frame_size) < 0) {
|
|
free(dst_buffer);
|
|
break;
|
|
}
|
|
}
|
|
if (meta_size) {
|
|
debug_print(DEBUG_FRAME, "\t meta len=%d\n", meta_size);
|
|
/* dump meta here */
|
|
}
|
|
free(dst_buffer);
|
|
frame_count++;
|
|
}
|
|
debug_print(DEBUG_STATE, "Process %d frame\n", frame_count);
|
|
free(meta_buffer);
|
|
return 0;
|
|
}
|
|
|
|
/****************** end of ivf parer *************/
|
|
|
|
#if 1
|
|
//AV1
|
|
static int obu_frame_frame_head_come_after_tile = 0;
|
|
//static int frame_decoded = 0;
|
|
static int decoding_data_flag = 0;
|
|
#endif
|
|
|
|
unsigned char is_picture_start(int nal_unit_type)
|
|
{
|
|
unsigned char ret = 0;
|
|
if (video_type == VFORMAT_AVS) {
|
|
if (nal_unit_type == 0xB3 || //I_PICTURE_START_CODE
|
|
nal_unit_type == 0xB6 //PB_PICTURE_START_CODE
|
|
)
|
|
ret = 1;
|
|
} else if (video_type == VFORMAT_VP9) {
|
|
/*to do*/
|
|
goto check_av1;
|
|
} else if (video_type == VFORMAT_AV1) {
|
|
check_av1:
|
|
if (nal_unit_type == OBU_FRAME_HEADER ||
|
|
nal_unit_type == OBU_FRAME) {
|
|
ret = 1;
|
|
obu_frame_frame_head_come_after_tile = 1;
|
|
if (nal_unit_type == OBU_FRAME) { /*have tile group in this OBU*/
|
|
obu_frame_frame_head_come_after_tile = 0;
|
|
decoding_data_flag = 1;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
ret = 1;
|
|
return ret;
|
|
}
|
|
|
|
unsigned char is_picture_end(int nal_unit_type)
|
|
{
|
|
unsigned char ret = 0;
|
|
if (video_type == VFORMAT_AVS) {
|
|
if (nal_unit_type == 0xB3 || //I_PICTURE_START_CODE
|
|
nal_unit_type == 0xB6 || //PB_PICTURE_START_CODE
|
|
nal_unit_type == 0xB0 || //SEQUENCE_HEADER_CODE
|
|
nal_unit_type == 0xB1 //SEQUENCE_END_CODE
|
|
)
|
|
ret = 1;
|
|
} else if (video_type == VFORMAT_VP9) {
|
|
/*to do*/
|
|
goto check_av1;
|
|
} else if (video_type == VFORMAT_AV1) {
|
|
check_av1:
|
|
if (nal_unit_type == OBU_TILE_GROUP) {
|
|
obu_frame_frame_head_come_after_tile = 0;
|
|
decoding_data_flag = 1;
|
|
} else if (nal_unit_type == OBU_FRAME_HEADER ||
|
|
nal_unit_type == OBU_FRAME) {
|
|
if (decoding_data_flag)
|
|
ret = 1;
|
|
decoding_data_flag = 0;
|
|
obu_frame_frame_head_come_after_tile = 1;
|
|
if (nal_unit_type == OBU_FRAME) { /*have tile group in this OBU*/
|
|
obu_frame_frame_head_come_after_tile = 0;
|
|
decoding_data_flag = 1;
|
|
}
|
|
} else if (nal_unit_type == OBU_REDUNDANT_FRAME_HEADER &&
|
|
obu_frame_frame_head_come_after_tile == 0) {
|
|
decoding_data_flag = 0;
|
|
debug_print(DEBUG_ERROR, "Warning, OBU_REDUNDANT_FRAME_HEADER come without OBU_FRAME or OBU_FRAME_HEAD\n");
|
|
}
|
|
} else
|
|
ret = 1;
|
|
return ret;
|
|
}
|
|
|
|
typedef struct
|
|
{
|
|
int startcodeprefix_len; //! 4 for parameter sets and first slice in picture, 3 for everything else (suggested)
|
|
unsigned len; //! Length of the NAL unit (Excluding the start code, which does not belong to the NALU)
|
|
unsigned max_size; //! Nal Unit Buffer size
|
|
int forbidden_bit; //! should be always FALSE
|
|
int nal_reference_idc; //! NALU_PRIORITY_xxxx
|
|
int nal_unit_type; //! NALU_TYPE_xxxx
|
|
unsigned char *buf; //! contains the first byte followed by the EBSP
|
|
unsigned short lost_packets; //! true, if packet loss is detected
|
|
} NALU_t;
|
|
|
|
NALU_t *AllocNALU(int buffersize)
|
|
{
|
|
NALU_t *n;
|
|
|
|
if ((n = (NALU_t*)calloc (1, sizeof (NALU_t))) == NULL) {
|
|
debug_print(DEBUG_ERROR, "AllocNALU: n");
|
|
exit(0);
|
|
}
|
|
|
|
n->max_size=buffersize;
|
|
|
|
if ((n->buf = (unsigned char*)calloc (buffersize, sizeof (char))) == NULL) {
|
|
free (n);
|
|
debug_print(DEBUG_ERROR, "AllocNALU: n->buf");
|
|
exit(0);
|
|
}
|
|
|
|
return n;
|
|
}
|
|
|
|
void FreeNALU(NALU_t *n)
|
|
{
|
|
if (n) {
|
|
if (n->buf) {
|
|
free(n->buf);
|
|
n->buf=NULL;
|
|
}
|
|
free (n);
|
|
}
|
|
}
|
|
|
|
static int FindStartCode2 (unsigned char *Buf)
|
|
{
|
|
if ((Buf[0] != 0) || (Buf[1] != 0) || (Buf[2] != 1)) return 0; //0x000001
|
|
else return 1;
|
|
}
|
|
|
|
static int FindStartCode3 (unsigned char *Buf)
|
|
{
|
|
if ((Buf[0] != 0) || (Buf[1] != 0) || (Buf[2] != 0) || (Buf[3] != 1)) return 0;//0x00000001
|
|
else return 1;
|
|
}
|
|
|
|
static int FindAmlStartCode(unsigned char *Buf)
|
|
{
|
|
unsigned int len;
|
|
unsigned int len2;
|
|
len = (Buf[0] << 24) | (Buf[1] << 16) | (Buf[2] << 8) | (Buf[3] << 0);
|
|
len2 = (Buf[4] << 24) | (Buf[5] << 16) | (Buf[6] << 8) | (Buf[7] << 0);
|
|
if (((len + len2) == 0xffffffff) &&
|
|
(Buf[8] == 0 && Buf[9] == 0 && Buf[10] == 0 && Buf[11] == 1) &&
|
|
(Buf[12] == 0x41 && Buf[13] == 0x4d && Buf[14] == 0x4c && Buf[15] == 0x56)) {
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int fgetc_direct(FILE *fe)
|
|
{
|
|
int ret;
|
|
|
|
ret = fgetc(fe);
|
|
return (ret != EOF) ? ret : '0';
|
|
}
|
|
|
|
int GetAnnexbNALU (FILE* fe, NALU_t *nalu)
|
|
{
|
|
int pos = 0;
|
|
int StartCodeFound, rewind;
|
|
unsigned char *Buf;
|
|
int info2 = 0, info3 = 0;
|
|
int i;
|
|
int prefix_len = 4;
|
|
if (video_type == VFORMAT_VP9 || video_type == VFORMAT_AV1)
|
|
prefix_len = 16;
|
|
if ((Buf = (unsigned char*)calloc (nalu->max_size , sizeof(char))) == NULL) {
|
|
debug_print(DEBUG_ERROR, "GetAnnexbNALU: Could not allocate Buf memory\n");
|
|
return -1;
|
|
}
|
|
|
|
nalu->startcodeprefix_len=0;
|
|
while (!feof(fe)) {
|
|
if (nalu->startcodeprefix_len<prefix_len) {
|
|
Buf[nalu->startcodeprefix_len++] = fgetc_direct(fe);
|
|
} else{
|
|
if (prefix_len == 4) {
|
|
for (i = 0; i < 3; i++)
|
|
Buf[i] = Buf[i+1];
|
|
} else {
|
|
for (i = 0; i < prefix_len; i++)
|
|
Buf[i] = Buf[i+1];
|
|
}
|
|
Buf[nalu->startcodeprefix_len - 1] = fgetc_direct(fe);
|
|
}
|
|
if (prefix_len == 4) {
|
|
if (nalu->startcodeprefix_len >= 3) {
|
|
if (FindStartCode2(Buf)) {
|
|
pos = nalu->startcodeprefix_len;
|
|
nalu->startcodeprefix_len = 3;
|
|
break;
|
|
}
|
|
}
|
|
if (nalu->startcodeprefix_len == 4) {
|
|
if (FindStartCode3(Buf)) {
|
|
pos = nalu->startcodeprefix_len;
|
|
break;
|
|
}
|
|
}
|
|
} else {
|
|
if (nalu->startcodeprefix_len == prefix_len) {
|
|
if (FindAmlStartCode(Buf)) {
|
|
pos = nalu->startcodeprefix_len;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
StartCodeFound = 0;
|
|
info2 = 0;
|
|
info3 = 0;
|
|
|
|
while (!StartCodeFound) {
|
|
if (feof (fe)) {
|
|
rewind = -1;
|
|
goto fill_data;
|
|
}
|
|
Buf[pos++] = fgetc_direct (fe);
|
|
if (prefix_len == 4) {
|
|
info3 = FindStartCode3(&Buf[pos - 4]);
|
|
if (info3 != 1)
|
|
info2 = FindStartCode2(&Buf[pos - 3]);
|
|
StartCodeFound = (info2 == 1 || info3 == 1);
|
|
} else {
|
|
StartCodeFound = FindAmlStartCode(&Buf[pos-prefix_len]);
|
|
}
|
|
}
|
|
|
|
// Here, we have found another start code (and read length of startcode bytes more than we should
|
|
// have. Hence, go back in the file
|
|
if (prefix_len == 4)
|
|
rewind = (info3 == 1) ? -4 : -3;
|
|
else
|
|
rewind = -prefix_len;
|
|
|
|
if (0 != fseek (fe, rewind, SEEK_CUR))
|
|
debug_print(DEBUG_ERROR, "GetAnnexbNALU: Cannot fseek in the bit stream file");
|
|
|
|
// Here the Start code, the complete NALU, and the next start code is in the Buf.
|
|
// The size of Buf is pos, pos+rewind are the number of bytes excluding the next
|
|
// start code, and (pos+rewind)-startcodeprefix_len is the size of the NALU excluding the start code
|
|
fill_data:
|
|
nalu->len = (pos + rewind);
|
|
if (nalu->len > MAX_SIZE) {
|
|
debug_print(DEBUG_ERROR, "%d: Error: to many data to copy %d\n", __LINE__, nalu->len);
|
|
exit(0);
|
|
}
|
|
memcpy (nalu->buf, &Buf[0], nalu->len);//copy nalu, include 0x000001 or 0x00000001
|
|
if (video_type == VFORMAT_VP9 || video_type == VFORMAT_AV1) {
|
|
unsigned char* p = &nalu->buf[nalu->startcodeprefix_len];
|
|
while ((*p++)&0x80) {
|
|
|
|
}
|
|
nalu->nal_reference_idc = 0;
|
|
nalu->forbidden_bit = *p & 0x80;
|
|
nalu->nal_unit_type = (*p>>3)&0xf;
|
|
} else {
|
|
nalu->forbidden_bit = nalu->buf[nalu->startcodeprefix_len] & 0x80; //1 bit
|
|
nalu->nal_reference_idc = nalu->buf[nalu->startcodeprefix_len] & 0x60; // 2 bit
|
|
//nalu->nal_unit_type = (nalu->buf[0]) & 0x1f;// 5 bit
|
|
nalu->nal_unit_type = (nalu->buf[nalu->startcodeprefix_len]);
|
|
}
|
|
free(Buf);
|
|
|
|
return (pos + rewind);
|
|
}
|
|
|
|
static void dump(NALU_t *n)
|
|
{
|
|
if (!n)return;
|
|
/*
|
|
printf("a new nal:");
|
|
|
|
printf(" len: %d ", n->len);
|
|
printf("nal_unit_type: %x\n", n->nal_unit_type);
|
|
*/
|
|
}
|
|
|
|
int av1_frame_mode_write_dat(FILE *fp, char *buffer)
|
|
{
|
|
NALU_t *n = AllocNALU(MAX_SIZE);
|
|
int buf_pos = 0;
|
|
|
|
|
|
//unsigned char pic_head_found = 0;
|
|
while (!feof(fp)) {
|
|
GetAnnexbNALU(fp, n);
|
|
dump(n);
|
|
if ((buf_pos + n->len) > BUFFER_SIZE) {
|
|
debug_print(DEBUG_ERROR, "%d: Error: to many data to copy %d\n", __LINE__, buf_pos + n->len);
|
|
exit(0);
|
|
}
|
|
memcpy(&buffer[buf_pos], n->buf, n->len);
|
|
buf_pos += n->len;
|
|
if (is_picture_start(n->nal_unit_type)) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
while (!feof(fp)) {
|
|
GetAnnexbNALU(fp, n);
|
|
if (is_picture_end(n->nal_unit_type)) {
|
|
//printf("Send Data Size =%d\n", buf_pos);
|
|
#ifndef TEST_ON_PC
|
|
/*
|
|
int delay_time = 0;
|
|
if (delay_time > 0)
|
|
delay(delay_time);
|
|
*/
|
|
if (send_buffer_to_device(buffer, buf_pos) < 0)
|
|
goto error_ret;
|
|
#endif
|
|
buf_pos = 0;
|
|
}
|
|
|
|
if ((buf_pos + n->len) > BUFFER_SIZE) {
|
|
debug_print(DEBUG_ERROR, "%d: Error: to many data to copy %d\n", __LINE__, buf_pos + n->len);
|
|
goto error_ret;
|
|
}
|
|
|
|
memcpy(&buffer[buf_pos], n->buf, n->len);
|
|
buf_pos += n->len;
|
|
dump(n);
|
|
}
|
|
error_ret:
|
|
free(n);
|
|
return 0;
|
|
}
|
|
|
|
static int padding_for_mpeg12_dma_frame(char *buffer, int frame_size)
|
|
{
|
|
if ((g_mem_type == V4LPLAYER_MEM_TYPE_DMA) &&
|
|
(g_play_mode == V4LPLAYER_FRAME_MODE) &&
|
|
(video_type == VFORMAT_MPEG12)) {
|
|
buffer[frame_size] = 0x00;
|
|
buffer[frame_size + 1] = 0x00;
|
|
buffer[frame_size + 2] = 0x01;
|
|
buffer[frame_size + 3] = 0x00;
|
|
|
|
return (frame_size + 4);
|
|
}
|
|
|
|
return frame_size;
|
|
}
|
|
|
|
int frame_mode_write_dat(FILE *fp, FILE *fszp, char *buffer)
|
|
{
|
|
char frame_size_str[32];
|
|
char *s_rt;
|
|
int frame_size;
|
|
int ret;
|
|
|
|
while (!feof(fp)) {
|
|
memset(frame_size_str, 0, sizeof(frame_size_str));
|
|
s_rt = fgets(frame_size_str, 32, fszp);
|
|
if (s_rt == NULL)
|
|
break;
|
|
frame_size = atoi(frame_size_str);
|
|
if (frame_size) {
|
|
memset(buffer, 0, BUFFER_SIZE);
|
|
ret = fread(buffer, 1, frame_size, fp);
|
|
ret = padding_for_mpeg12_dma_frame(buffer, frame_size);
|
|
#ifdef DEBUG_FRAME
|
|
debug_print(DEBUG_FRAME, "read size %d/%d, %x %x %x %x %x %x %x %x ...\n", ret, frame_size,
|
|
buffer[0], buffer[1], buffer[2], buffer[3], buffer[4], buffer[5], buffer[6], buffer[7]);
|
|
#endif
|
|
if (ret < frame_size)
|
|
debug_print(DEBUG_ERROR, "read back size %d, less than frame size %d\n", ret, frame_size);
|
|
else {
|
|
if (send_buffer_to_device(buffer, ret) < 0) {
|
|
debug_print(DEBUG_ERROR, "send data failed\n");
|
|
break;
|
|
}
|
|
}
|
|
} else
|
|
debug_print(DEBUG_ERROR, "error: read frame size 0\n");
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int stream_mode_write_dat(FILE *fp, char *buffer)
|
|
{
|
|
int ret;
|
|
char padding[STREAM_MODE_WRITE_BLOCK_SIZE] = {0};
|
|
|
|
while (!feof(fp)) {
|
|
memset(buffer, 0, BUFFER_SIZE);
|
|
ret = fread(buffer, 1, STREAM_MODE_WRITE_BLOCK_SIZE, fp);
|
|
if (ret == 0) {
|
|
debug_print(DEBUG_ERROR, "error write data done\n");
|
|
break;
|
|
}else if(ret < 0) {
|
|
debug_print(DEBUG_ERROR, "error write data error:%d\n", ret);
|
|
} else {
|
|
if (send_buffer_to_device(buffer, ret) < 0) {
|
|
debug_print(DEBUG_ERROR, "send data failed\n");
|
|
break;
|
|
}
|
|
}
|
|
// can not get read point, it's meaningless to use 'ring_buf.start',
|
|
// in other word, we cannot know whether buf is full or not, so write buf must sleep.
|
|
usleep(100 * 1000);
|
|
}
|
|
|
|
send_buffer_to_device(padding, STREAM_MODE_WRITE_BLOCK_SIZE);
|
|
|
|
debug_print(0, "stream write data done\n");
|
|
return 0;
|
|
}
|
|
|
|
static void usage()
|
|
{
|
|
printf("Command help:\n");
|
|
printf("1. To play a video: v4lplayer -i <file> -f <format> -d <dw_mode> -s <FSZ> -l <log_level> -o <dump> -n <num>\n");
|
|
printf(" -i, --ifile, input es file\n");
|
|
printf(" -f, --format, video format\n");
|
|
printf("\t0:mpeg12\t1:mpeg4\t\t2:h264\t\t3:mjpeg\n");
|
|
printf("\t5:jpeg\t\t6:vc1\t\t7:avs\t\t11:hevc\n");
|
|
printf("\t14:vp9\t\t15:avs2\t\t16:av1\t\t17:avs3\n");
|
|
printf("\t18:h266\n");
|
|
printf(" -s, --size, frame size file\n");
|
|
printf(" -d, --dw_mode: (No dw mode will be forced to dw 16)\n");
|
|
printf("\t0: no DW compressed only\n");
|
|
printf("\t1: DW with 1:1 ratio\n");
|
|
printf("\t2: DW with 1:4 down sample\n");
|
|
printf("\t3: DW with 1:4 down sample\n");
|
|
printf("\t4: DW with 1:2 down sample\n");
|
|
printf("\t16: DW only\n");
|
|
printf(" -l, --log_level, enable more log\n");
|
|
printf("\tbit 0: decoder state\tbit 1: debug frame\n");
|
|
printf(" -o, --output, output yuv and crc\n");
|
|
printf("\tbit 0: print crc\n");
|
|
printf("\tbit 1: dump yuv to /data/tmp\n");
|
|
printf("\tbit 2: dump crc to /data/tmp\n");
|
|
printf("\tbit 3: reserved\n");
|
|
printf("\tbit 4: dump stream info to /data/tmp\n");
|
|
printf("\tbit 5: dump statistic info to /data/tmp\n");
|
|
printf("\tbit 6: dump afd info to /data/tmp\n");
|
|
printf("\tbit 7: dump cc info to /data/tmp\n");
|
|
printf("\tbit 8: dump hdr10 info to /data/tmp\n");
|
|
printf("\tbit 9: dump hdr10p info to /data/tmp\n");
|
|
printf("\tbit 10: dump cuva info to /data/tmp\n");
|
|
printf("\tbit 11: dump amdv info to /data/tmp\n");
|
|
printf("\tbit 12: dump frame info to /data/tmp\n");
|
|
printf("\tBefore dumping, run 'mkdir -p /data/tmp -m 777;setenforce 0;rm /data/tmp/* -rf' command\n");
|
|
printf(" -n, --number, dump decoder info num\n");
|
|
printf(" -p, --pix_fmt, set nv12 or nv21\n");
|
|
printf(" -m, memory_type and play_mode:\n");
|
|
printf("\t bit:0 memory type: 0 for mmap , 1 for dma\n");
|
|
printf("\t bit:1 play_mode: 0 for frame mode , 1 for stream mode\n");
|
|
printf(" -h, --help, usage\n");
|
|
printf("example : v4lplayer -f 2 -d 16 -i /data/h264.es -s /data/h264.fsz\n");
|
|
printf("--subformat, additional arg for vc1 video\n");
|
|
printf("\t0: WMV3 video\t1: WVC1 video\n");
|
|
}
|
|
|
|
static const char short_options[] = "i:s:d:f:l:o:n:p:m:h";
|
|
|
|
static const struct option
|
|
long_options[] = {
|
|
{ "sizefile", required_argument, NULL, 's' },
|
|
{ "ifile", required_argument, NULL, 'i' },
|
|
{ "double_write", required_argument, NULL, 'd' },
|
|
{ "format", required_argument, NULL, 'f' },
|
|
{ "log", required_argument, NULL, 'l' },
|
|
{ "output", required_argument, NULL, 'o' },
|
|
{ "num", required_argument, NULL, 'n' },
|
|
{ "help", no_argument, NULL, 'h' },
|
|
{ "mem_and_mode", required_argument, NULL, 'm' },
|
|
{ "pix_fmt", required_argument, NULL, 'p' },
|
|
{ "subformat", required_argument, NULL, 0 },
|
|
{ 0, 0, 0, 0 }
|
|
};
|
|
|
|
static int parse_para(int argc, char *argv[])
|
|
{
|
|
for (;;) {
|
|
int idx;
|
|
int c;
|
|
unsigned long value = 0;
|
|
char *endptr;
|
|
|
|
c = getopt_long(argc, argv, short_options, long_options, &idx);
|
|
|
|
if (-1 == c)
|
|
break;
|
|
|
|
switch (c) {
|
|
case 0: /* getopt_long() flag */
|
|
if (strcmp(long_options[idx].name, "subformat") == 0) {
|
|
value = atoi(optarg);
|
|
if (!(value == 0 || value == 1)) {
|
|
debug_print(DEBUG_ERROR, "invalid subformat %d\n",
|
|
value);
|
|
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
set_vc1_subformat(value);
|
|
}
|
|
break;
|
|
case 'l':
|
|
g_log_level = atoi(optarg);
|
|
break;
|
|
case 'd':
|
|
if (strncmp(optarg, "0x", 2) == 0 || strncmp(optarg, "0X", 2) == 0) {
|
|
value = strtoul(optarg, &endptr, 16);
|
|
} else {
|
|
value = strtoul(optarg, &endptr, 10);
|
|
}
|
|
|
|
if (*endptr != '\0') {
|
|
debug_print(DEBUG_ERROR, "Invalid value -o: %s\n", optarg);
|
|
break;
|
|
}
|
|
|
|
g_dw_mode = value;
|
|
if (g_dw_mode != 0 &&
|
|
g_dw_mode != 1 &&
|
|
g_dw_mode != 2 &&
|
|
g_dw_mode != 3 &&
|
|
g_dw_mode != 4 &&
|
|
g_dw_mode != 16 &&
|
|
g_dw_mode != 0x200) {
|
|
debug_print(DEBUG_ERROR, "invalid dw_mode 0x%x\n", g_dw_mode);
|
|
exit(1);
|
|
}
|
|
break;
|
|
case 'p':
|
|
pix_name = optarg;
|
|
if (!strcmp(pix_name, "nv12"))
|
|
g_nv21 = 0;
|
|
else if (!strcmp(pix_name, "nv21"))
|
|
g_nv21 = 1;
|
|
else
|
|
debug_print(DEBUG_ERROR, "invalid pix_name %s\n", pix_name);
|
|
break;
|
|
case 'f':
|
|
video_type = atoi(optarg);
|
|
break;
|
|
case 'i':
|
|
filename = strdup(optarg);
|
|
break;
|
|
case 's':
|
|
frame_size_file = strdup(optarg);
|
|
break;
|
|
case 'o':
|
|
if (strncmp(optarg, "0x", 2) == 0 || strncmp(optarg, "0X", 2) == 0) {
|
|
value = strtoul(optarg, &endptr, 16);
|
|
} else {
|
|
value = strtoul(optarg, &endptr, 10);
|
|
}
|
|
|
|
if (*endptr != '\0') {
|
|
debug_print(DEBUG_ERROR, "Invalid value -o: %s\n", optarg);
|
|
break;
|
|
}
|
|
|
|
g_output_flag = value;
|
|
debug_print(DEBUG_DEF, "set output: %d\n", value);
|
|
break;
|
|
case 'n':
|
|
g_dump_dec_info_num = atoi(optarg);
|
|
break;
|
|
case 'h':
|
|
usage();
|
|
return -1;
|
|
case 'm':
|
|
if (strncmp(optarg, "0x", 2) == 0 || strncmp(optarg, "0X", 2) == 0) {
|
|
value = strtoul(optarg, &endptr, 16);
|
|
} else {
|
|
value = strtoul(optarg, &endptr, 10);
|
|
}
|
|
|
|
if (*endptr != '\0') {
|
|
debug_print(DEBUG_ERROR, "Invalid value -m: %s\n", optarg);
|
|
break;
|
|
}
|
|
|
|
if (value & 0b1) {
|
|
g_mem_type = V4LPLAYER_MEM_TYPE_DMA;
|
|
}
|
|
|
|
if (value & 0b10) {
|
|
g_play_mode = V4LPLAYER_STREAM_MODE;
|
|
g_mem_type = V4LPLAYER_MEM_TYPE_DMA; // force dma
|
|
}
|
|
|
|
break;
|
|
default:
|
|
usage();
|
|
return -1;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static void decode_finish()
|
|
{
|
|
sem_post(&wait_for_end);
|
|
}
|
|
|
|
static int start_decoder(enum vformat_e type)
|
|
{
|
|
int ret;
|
|
ret = v4l2_dec_init(type, decode_finish);
|
|
if (ret) {
|
|
debug_print(DEBUG_ERROR, "FATAL: start_decoder error:%d\n",ret);
|
|
exit(1);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int main(int argc, char *argv[])
|
|
{
|
|
FILE* frame_size_fp = NULL;
|
|
char *buffer = NULL;
|
|
|
|
if (argc < 6) {
|
|
usage();
|
|
return -1;
|
|
}
|
|
|
|
g_dw_mode = 16;
|
|
g_nv21 = 1;
|
|
if (parse_para(argc, argv))
|
|
return -1;
|
|
|
|
buffer = malloc(BUFFER_SIZE);
|
|
if (NULL == buffer) {
|
|
debug_print(DEBUG_ERROR, "malloc write buffer fail\n");
|
|
return -1;
|
|
}
|
|
memset(buffer, 0, BUFFER_SIZE);
|
|
|
|
debug_print(DEBUG_STATE, "set dw mode:%d, nv21:%d\n", g_dw_mode, g_nv21);
|
|
if (((frame_size_fp = fopen(frame_size_file, "rb")) == NULL) &&
|
|
video_type != VFORMAT_AV1 && g_play_mode == V4LPLAYER_FRAME_MODE) {
|
|
debug_print(DEBUG_ERROR, "open file %s error!, force stream mode\n", frame_size_file);
|
|
return -1;
|
|
}
|
|
|
|
debug_print(DEBUG_DEF, "\n*********CODEC PLAYER DEMO************\n\n");
|
|
debug_print(DEBUG_DEF, "file %s to be played\n", filename);
|
|
|
|
if ((fp = fopen(filename, "rb")) == NULL) {
|
|
debug_print(DEBUG_ERROR, "open file error!\n");
|
|
goto free_buff;
|
|
}
|
|
|
|
start_decoder(video_type);
|
|
if (g_play_mode == V4LPLAYER_STREAM_MODE) {
|
|
stream_mode_write_dat(fp, buffer);
|
|
}else {
|
|
if (is_video_file_type_ivf(fp, buffer)) {
|
|
if (video_type == VFORMAT_AV1) {
|
|
debug_print(DEBUG_DEF, "input video file is ivf with av1.\n");
|
|
av1_ivf_write_dat(fp, (uint8_t *)buffer);
|
|
}
|
|
} else {
|
|
if ((video_type == VFORMAT_AV1) && (frame_size_fp == NULL))
|
|
av1_frame_mode_write_dat(fp, buffer);
|
|
else {
|
|
if (!frame_size_file) {
|
|
debug_print(DEBUG_ERROR, "open file %s error!, force stream mode\n", frame_size_file);
|
|
goto free_buff;
|
|
}
|
|
frame_mode_write_dat(fp, frame_size_fp, buffer);
|
|
}
|
|
}
|
|
}
|
|
v4l2_dec_eos();
|
|
sem_wait(&wait_for_end);
|
|
|
|
error:
|
|
v4l2_dec_destroy();
|
|
sem_destroy(&wait_for_end);
|
|
fclose(fp);
|
|
free_buff:
|
|
free(buffer);
|
|
return 0;
|
|
}
|
|
|