rtpenc_h263_rfc2190.c
Go to the documentation of this file.
1 /*
2  * RTP packetization for H.263 video
3  * Copyright (c) 2012 Martin Storsjo
4  *
5  * This file is part of Libav.
6  *
7  * Libav is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * Libav is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with Libav; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 #include "avformat.h"
23 #include "rtpenc.h"
24 #include "libavcodec/put_bits.h"
25 #include "libavcodec/get_bits.h"
26 
27 struct H263Info {
28  int src;
29  int i;
30  int u;
31  int s;
32  int a;
33  int pb;
34  int tr;
35 };
36 
37 struct H263State {
38  int gobn;
39  int mba;
40  int hmv1, vmv1, hmv2, vmv2;
41  int quant;
42 };
43 
44 static void send_mode_a(AVFormatContext *s1, const struct H263Info *info,
45  const uint8_t *buf, int len, int ebits, int m)
46 {
47  RTPMuxContext *s = s1->priv_data;
49 
50  init_put_bits(&pb, s->buf, 32);
51  put_bits(&pb, 1, 0); /* F - 0, mode A */
52  put_bits(&pb, 1, 0); /* P - 0, normal I/P */
53  put_bits(&pb, 3, 0); /* SBIT - 0 bits */
54  put_bits(&pb, 3, ebits); /* EBIT */
55  put_bits(&pb, 3, info->src); /* SRC - source format */
56  put_bits(&pb, 1, info->i); /* I - inter/intra */
57  put_bits(&pb, 1, info->u); /* U - unrestricted motion vector */
58  put_bits(&pb, 1, info->s); /* S - syntax-baesd arithmetic coding */
59  put_bits(&pb, 1, info->a); /* A - advanced prediction */
60  put_bits(&pb, 4, 0); /* R - reserved */
61  put_bits(&pb, 2, 0); /* DBQ - 0 */
62  put_bits(&pb, 3, 0); /* TRB - 0 */
63  put_bits(&pb, 8, info->tr); /* TR */
64  flush_put_bits(&pb);
65  memcpy(s->buf + 4, buf, len);
66 
67  ff_rtp_send_data(s1, s->buf, len + 4, m);
68 }
69 
70 static void send_mode_b(AVFormatContext *s1, const struct H263Info *info,
71  const struct H263State *state, const uint8_t *buf,
72  int len, int sbits, int ebits, int m)
73 {
74  RTPMuxContext *s = s1->priv_data;
76 
77  init_put_bits(&pb, s->buf, 64);
78  put_bits(&pb, 1, 1); /* F - 1, mode B */
79  put_bits(&pb, 1, 0); /* P - 0, mode B */
80  put_bits(&pb, 3, sbits); /* SBIT - 0 bits */
81  put_bits(&pb, 3, ebits); /* EBIT - 0 bits */
82  put_bits(&pb, 3, info->src); /* SRC - source format */
83  put_bits(&pb, 5, state->quant); /* QUANT - quantizer for the first MB */
84  put_bits(&pb, 5, state->gobn); /* GOBN - GOB number */
85  put_bits(&pb, 9, state->mba); /* MBA - MB address */
86  put_bits(&pb, 2, 0); /* R - reserved */
87  put_bits(&pb, 1, info->i); /* I - inter/intra */
88  put_bits(&pb, 1, info->u); /* U - unrestricted motion vector */
89  put_bits(&pb, 1, info->s); /* S - syntax-baesd arithmetic coding */
90  put_bits(&pb, 1, info->a); /* A - advanced prediction */
91  put_bits(&pb, 7, state->hmv1); /* HVM1 - horizontal motion vector 1 */
92  put_bits(&pb, 7, state->vmv1); /* VMV1 - vertical motion vector 1 */
93  put_bits(&pb, 7, state->hmv2); /* HVM2 - horizontal motion vector 2 */
94  put_bits(&pb, 7, state->vmv2); /* VMV2 - vertical motion vector 2 */
95  flush_put_bits(&pb);
96  memcpy(s->buf + 8, buf, len);
97 
98  ff_rtp_send_data(s1, s->buf, len + 8, m);
99 }
100 
102  const uint8_t *mb_info, int mb_info_size)
103 {
104  RTPMuxContext *s = s1->priv_data;
105  int len, sbits = 0, ebits = 0;
106  GetBitContext gb;
107  struct H263Info info = { 0 };
108  struct H263State state = { 0 };
109  int mb_info_pos = 0, mb_info_count = mb_info_size / 12;
110  const uint8_t *buf_base = buf;
111 
112  s->timestamp = s->cur_timestamp;
113 
114  init_get_bits(&gb, buf, size*8);
115  if (get_bits(&gb, 22) == 0x20) { /* Picture Start Code */
116  info.tr = get_bits(&gb, 8);
117  skip_bits(&gb, 2); /* PTYPE start, H261 disambiguation */
118  skip_bits(&gb, 3); /* Split screen, document camera, freeze picture release */
119  info.src = get_bits(&gb, 3);
120  info.i = get_bits(&gb, 1);
121  info.u = get_bits(&gb, 1);
122  info.s = get_bits(&gb, 1);
123  info.a = get_bits(&gb, 1);
124  info.pb = get_bits(&gb, 1);
125  }
126 
127  while (size > 0) {
128  struct H263State packet_start_state = state;
129  len = FFMIN(s->max_payload_size - 8, size);
130 
131  /* Look for a better place to split the frame into packets. */
132  if (len < size) {
134  buf + len);
135  len = end - buf;
136  if (len == s->max_payload_size - 8) {
137  /* Skip mb info prior to the start of the current ptr */
138  while (mb_info_pos < mb_info_count) {
139  uint32_t pos = AV_RL32(&mb_info[12*mb_info_pos])/8;
140  if (pos >= buf - buf_base)
141  break;
142  mb_info_pos++;
143  }
144  /* Find the first mb info past the end pointer */
145  while (mb_info_pos + 1 < mb_info_count) {
146  uint32_t pos = AV_RL32(&mb_info[12*(mb_info_pos + 1)])/8;
147  if (pos >= end - buf_base)
148  break;
149  mb_info_pos++;
150  }
151  if (mb_info_pos < mb_info_count) {
152  const uint8_t *ptr = &mb_info[12*mb_info_pos];
153  uint32_t bit_pos = AV_RL32(ptr);
154  uint32_t pos = (bit_pos + 7)/8;
155  if (pos <= end - buf_base) {
156  state.quant = ptr[4];
157  state.gobn = ptr[5];
158  state.mba = AV_RL16(&ptr[6]);
159  state.hmv1 = (int8_t) ptr[8];
160  state.vmv1 = (int8_t) ptr[9];
161  state.hmv2 = (int8_t) ptr[10];
162  state.vmv2 = (int8_t) ptr[11];
163  ebits = 8 * pos - bit_pos;
164  len = pos - (buf - buf_base);
165  mb_info_pos++;
166  } else {
167  av_log(s1, AV_LOG_ERROR,
168  "Unable to split H263 packet, use -mb_info %d "
169  "or lower.\n", s->max_payload_size - 8);
170  }
171  } else {
172  av_log(s1, AV_LOG_ERROR, "Unable to split H263 packet, "
173  "use -mb_info %d or -ps 1.\n",
174  s->max_payload_size - 8);
175  }
176  }
177  }
178 
179  if (size > 2 && !buf[0] && !buf[1])
180  send_mode_a(s1, &info, buf, len, ebits, len == size);
181  else
182  send_mode_b(s1, &info, &packet_start_state, buf, len, sbits,
183  ebits, len == size);
184 
185  if (ebits) {
186  sbits = 8 - ebits;
187  len--;
188  } else {
189  sbits = 0;
190  }
191  buf += len;
192  size -= len;
193  ebits = 0;
194  }
195 }
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:240
void ff_rtp_send_h263_rfc2190(AVFormatContext *s1, const uint8_t *buf, int size, const uint8_t *mb_info, int mb_info_size)
#define AV_RL16
int max_payload_size
Definition: rtpenc.h:38
static void send_mode_b(AVFormatContext *s1, const struct H263Info *info, const struct H263State *state, const uint8_t *buf, int len, int sbits, int ebits, int m)
Format I/O context.
Definition: avformat.h:944
uint8_t
window constants for m
end end
bitstream reader API header.
uint8_t * buf
Definition: rtpenc.h:51
void av_log(void *avcl, int level, const char *fmt,...)
Definition: log.c:246
static void put_bits(J2kEncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:160
int size
MIPS optimizations info
Definition: mips.txt:2
#define FFMIN(a, b)
Definition: common.h:58
void ff_rtp_send_data(AVFormatContext *s1, const uint8_t *buf1, int len, int m)
Definition: rtpenc.c:307
#define AV_RL32
uint32_t cur_timestamp
Definition: rtpenc.h:37
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:148
void * buf
Definition: avisynth_c.h:594
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:265
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:379
#define s1
Definition: regdef.h:38
static uint32_t state
Definition: trasher.c:27
Main libavformat public API header.
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
Definition: put_bits.h:81
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
Definition: put_bits.h:54
uint32_t timestamp
Definition: rtpenc.h:35
static void send_mode_a(AVFormatContext *s1, const struct H263Info *info, const uint8_t *buf, int len, int ebits, int m)
int len
void * priv_data
Format private data.
Definition: avformat.h:964
const uint8_t * ff_h263_find_resync_marker_reverse(const uint8_t *av_restrict start, const uint8_t *av_restrict end)
Definition: rtpenc_h263.c:26
bitstream writer API