1bd2d763 |
/*
* AVC helper functions for muxers
* Copyright (c) 2006 Baptiste Coudurier <baptiste.coudurier@smartjog.com>
*
* This file is part of FFmpeg.
*
* FFmpeg is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* FFmpeg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with FFmpeg; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/ |
6a5d31ac |
#include "libavutil/intreadwrite.h" |
1bd2d763 |
#include "avformat.h"
#include "avio.h" |
dda8fc6a |
#include "avc.h" |
1bd2d763 |
|
403c545d |
static const uint8_t *ff_avc_find_startcode_internal(const uint8_t *p, const uint8_t *end) |
1bd2d763 |
{ |
d4efacff |
const uint8_t *a = p + 4 - ((intptr_t)p & 3); |
1bd2d763 |
|
46c9eb57 |
for (end -= 3; p < a && p < end; p++) {
if (p[0] == 0 && p[1] == 0 && p[2] == 1) |
1bd2d763 |
return p;
}
|
46c9eb57 |
for (end -= 3; p < end; p += 4) { |
591de5cf |
uint32_t x = *(const uint32_t*)p; |
46c9eb57 |
// if ((x - 0x01000100) & (~x) & 0x80008000) // little endian
// if ((x - 0x00010001) & (~x) & 0x00800080) // big endian
if ((x - 0x01010101) & (~x) & 0x80808080) { // generic
if (p[1] == 0) {
if (p[0] == 0 && p[2] == 1) |
1bd2d763 |
return p; |
403c545d |
if (p[2] == 0 && p[3] == 1)
return p+1; |
1bd2d763 |
} |
46c9eb57 |
if (p[3] == 0) {
if (p[2] == 0 && p[4] == 1) |
1bd2d763 |
return p+2; |
403c545d |
if (p[4] == 0 && p[5] == 1)
return p+3; |
1bd2d763 |
}
}
}
|
46c9eb57 |
for (end += 3; p < end; p++) {
if (p[0] == 0 && p[1] == 0 && p[2] == 1) |
1bd2d763 |
return p;
}
return end + 3;
}
|
403c545d |
const uint8_t *ff_avc_find_startcode(const uint8_t *p, const uint8_t *end){
const uint8_t *out= ff_avc_find_startcode_internal(p, end);
if(p<out && out<end && !out[-1]) out--;
return out;
}
|
471fe57e |
int ff_avc_parse_nal_units(AVIOContext *pb, const uint8_t *buf_in, int size) |
1bd2d763 |
{ |
d937cd0e |
const uint8_t *p = buf_in; |
0a63a676 |
const uint8_t *end = p + size; |
d937cd0e |
const uint8_t *nal_start, *nal_end; |
1bd2d763 |
|
a97772b1 |
size = 0; |
b973f9ad |
nal_start = ff_avc_find_startcode(p, end); |
6c643e07 |
for (;;) {
while (nal_start < end && !*(nal_start++));
if (nal_start == end)
break;
|
b973f9ad |
nal_end = ff_avc_find_startcode(nal_start, end); |
e9eb8d0b |
avio_wb32(pb, nal_end - nal_start);
avio_write(pb, nal_start, nal_end - nal_start); |
a97772b1 |
size += 4 + nal_end - nal_start; |
1bd2d763 |
nal_start = nal_end;
} |
a97772b1 |
return size; |
0a63a676 |
}
|
d2984120 |
int ff_avc_parse_nal_units_buf(const uint8_t *buf_in, uint8_t **buf, int *size) |
0a63a676 |
{ |
471fe57e |
AVIOContext *pb; |
b92c5452 |
int ret = avio_open_dyn_buf(&pb); |
0a63a676 |
if(ret < 0)
return ret;
ff_avc_parse_nal_units(pb, buf_in, *size);
|
1bd2d763 |
av_freep(buf); |
6dc7d80d |
*size = avio_close_dyn_buf(pb, buf); |
1bd2d763 |
return 0;
}
|
471fe57e |
int ff_isom_write_avcc(AVIOContext *pb, const uint8_t *data, int len) |
1bd2d763 |
{ |
9cd361c5 |
uint8_t *buf = NULL, *end, *start = NULL;
uint8_t *sps = NULL, *pps = NULL;
uint32_t sps_size = 0, pps_size = 0;
int ret;
|
ae7df68e |
if (len <= 6)
return AVERROR_INVALIDDATA;
|
41ed7ab4 |
/* check for H.264 start code */ |
9cd361c5 |
if (AV_RB32(data) != 0x00000001 &&
AV_RB24(data) != 0x000001) {
avio_write(pb, data, len);
return 0;
} |
1bd2d763 |
|
9cd361c5 |
ret = ff_avc_parse_nal_units_buf(data, &buf, &len); |
1bd2d763 |
if (ret < 0)
return ret; |
d937cd0e |
start = buf; |
1bd2d763 |
end = buf + len;
/* look for sps and pps */ |
6c643e07 |
while (end - buf > 4) {
uint32_t size; |
1bd2d763 |
uint8_t nal_type; |
6c643e07 |
size = FFMIN(AV_RB32(buf), end - buf - 4);
buf += 4;
nal_type = buf[0] & 0x1f;
|
1bd2d763 |
if (nal_type == 7) { /* SPS */ |
6c643e07 |
sps = buf; |
1bd2d763 |
sps_size = size;
} else if (nal_type == 8) { /* PPS */ |
6c643e07 |
pps = buf; |
1bd2d763 |
pps_size = size;
} |
6c643e07 |
buf += size; |
1bd2d763 |
} |
6c643e07 |
if (!sps || !pps || sps_size < 4 || sps_size > UINT16_MAX || pps_size > UINT16_MAX)
return AVERROR_INVALIDDATA; |
1bd2d763 |
|
e9eb8d0b |
avio_w8(pb, 1); /* version */
avio_w8(pb, sps[1]); /* profile */
avio_w8(pb, sps[2]); /* profile compat */
avio_w8(pb, sps[3]); /* level */
avio_w8(pb, 0xff); /* 6 bits reserved (111111) + 2 bits nal size length - 1 (11) */
avio_w8(pb, 0xe1); /* 3 bits reserved (111) + 5 bits number of sps (00001) */
avio_wb16(pb, sps_size);
avio_write(pb, sps, sps_size);
avio_w8(pb, 1); /* number of pps */
avio_wb16(pb, pps_size);
avio_write(pb, pps, pps_size); |
d937cd0e |
av_free(start); |
1bd2d763 |
return 0;
} |
d5ed5e7d |
int ff_avc_write_annexb_extradata(const uint8_t *in, uint8_t **buf, int *size)
{
uint16_t sps_size, pps_size;
uint8_t *out;
int out_size;
*buf = NULL;
if (*size >= 4 && (AV_RB32(in) == 0x00000001 || AV_RB24(in) == 0x000001))
return 0;
if (*size < 11 || in[0] != 1)
return AVERROR_INVALIDDATA;
sps_size = AV_RB16(&in[6]);
if (11 + sps_size > *size)
return AVERROR_INVALIDDATA;
pps_size = AV_RB16(&in[9 + sps_size]);
if (11 + sps_size + pps_size > *size)
return AVERROR_INVALIDDATA;
out_size = 8 + sps_size + pps_size; |
29d147c9 |
out = av_mallocz(out_size + AV_INPUT_BUFFER_PADDING_SIZE); |
d5ed5e7d |
if (!out)
return AVERROR(ENOMEM);
AV_WB32(&out[0], 0x00000001);
memcpy(out + 4, &in[8], sps_size);
AV_WB32(&out[4 + sps_size], 0x00000001);
memcpy(out + 8 + sps_size, &in[11 + sps_size], pps_size);
*buf = out;
*size = out_size;
return 0;
} |
a2efbecc |
const uint8_t *ff_avc_mp4_find_startcode(const uint8_t *start,
const uint8_t *end,
int nal_length_size)
{
unsigned int res = 0;
if (end - start < nal_length_size)
return NULL;
while (nal_length_size--)
res = (res << 8) | *start++;
if (res > end - start)
return NULL;
return start + res;
} |