$treeview $search $mathjax
|
|
$projectbrief
|
$searchbox |
Typedefs | |
typedef OpusRepacketizer | OpusRepacketizer |
Functions | |
int | opus_repacketizer_get_size (void) |
Gets the size of an OpusRepacketizer structure. More... | |
OpusRepacketizer * | opus_repacketizer_init (OpusRepacketizer *rp) |
(Re)initializes a previously allocated repacketizer state. More... | |
OpusRepacketizer * | opus_repacketizer_create (void) |
Allocates memory and initializes the new repacketizer with opus_repacketizer_init(). More... | |
void | opus_repacketizer_destroy (OpusRepacketizer *rp) |
Frees an OpusRepacketizer allocated by opus_repacketizer_create(). More... | |
int | opus_repacketizer_cat (OpusRepacketizer *rp, const unsigned char *data, opus_int32 len) |
Add a packet to the current repacketizer state. More... | |
opus_int32 | opus_repacketizer_out_range (OpusRepacketizer *rp, int begin, int end, unsigned char *data, opus_int32 maxlen) |
Construct a new packet from data previously submitted to the repacketizer state via opus_repacketizer_cat(). More... | |
int | opus_repacketizer_get_nb_frames (OpusRepacketizer *rp) |
Return the total number of frames contained in packet data submitted to the repacketizer state so far via opus_repacketizer_cat() since the last call to opus_repacketizer_init() or opus_repacketizer_create(). More... | |
opus_int32 | opus_repacketizer_out (OpusRepacketizer *rp, unsigned char *data, opus_int32 maxlen) |
Construct a new packet from data previously submitted to the repacketizer state via opus_repacketizer_cat(). More... |
The repacketizing process starts with creating a repacketizer state, either by calling opus_repacketizer_create() or by allocating the memory yourself, e.g.,
OpusRepacketizer *rp; rp = (OpusRepacketizer*)malloc(opus_repacketizer_get_size()); if (rp != NULL) opus_repacketizer_init(rp);
Then the application should submit packets with opus_repacketizer_cat(), extract new packets with opus_repacketizer_out() or opus_repacketizer_out_range(), and then reset the state for the next set of input packets via opus_repacketizer_init().
For example, to split a sequence of packets into individual frames:
unsigned char *data; int len; while (get_next_packet(&data, &len)) { unsigned char out[1276]; opus_int32 out_len; int nb_frames; int err; int i; err = opus_repacketizer_cat(rp, data, len); if (err != OPUS_OK) { release_packet(data); return err; } nb_frames = opus_repacketizer_get_nb_frames(rp); for (i = 0; i < nb_frames; i++) { out_len = opus_repacketizer_out_range(rp, i, i+1, out, sizeof(out)); if (out_len < 0) { release_packet(data); return (int)out_len; } output_next_packet(out, out_len); } opus_repacketizer_init(rp); release_packet(data); }
Alternatively, to combine a sequence of frames into packets that each contain up to TARGET_DURATION_MS
milliseconds of data:
// The maximum number of packets with duration TARGET_DURATION_MS occurs // when the frame size is 2.5 ms, for a total of (TARGET_DURATION_MS*2/5) // packets. unsigned char *data[(TARGET_DURATION_MS*2/5)+1]; opus_int32 len[(TARGET_DURATION_MS*2/5)+1]; int nb_packets; unsigned char out[1277*(TARGET_DURATION_MS*2/2)]; opus_int32 out_len; int prev_toc; nb_packets = 0; while (get_next_packet(data+nb_packets, len+nb_packets)) { int nb_frames; int err; nb_frames = opus_packet_get_nb_frames(data[nb_packets], len[nb_packets]); if (nb_frames < 1) { release_packets(data, nb_packets+1); return nb_frames; } nb_frames += opus_repacketizer_get_nb_frames(rp); // If adding the next packet would exceed our target, or it has an // incompatible TOC sequence, output the packets we already have before // submitting it. // N.B., The nb_packets > 0 check ensures we've submitted at least one // packet since the last call to opus_repacketizer_init(). Otherwise a // single packet longer than TARGET_DURATION_MS would cause us to try to // output an (invalid) empty packet. It also ensures that prev_toc has // been set to a valid value. Additionally, len[nb_packets] > 0 is // guaranteed by the call to opus_packet_get_nb_frames() above, so the // reference to data[nb_packets][0] should be valid. if (nb_packets > 0 && ( ((prev_toc & 0xFC) != (data[nb_packets][0] & 0xFC)) || opus_packet_get_samples_per_frame(data[nb_packets], 48000)*nb_frames > TARGET_DURATION_MS*48)) { out_len = opus_repacketizer_out(rp, out, sizeof(out)); if (out_len < 0) { release_packets(data, nb_packets+1); return (int)out_len; } output_next_packet(out, out_len); opus_repacketizer_init(rp); release_packets(data, nb_packets); data[0] = data[nb_packets]; len[0] = len[nb_packets]; nb_packets = 0; } err = opus_repacketizer_cat(rp, data[nb_packets], len[nb_packets]); if (err != OPUS_OK) { release_packets(data, nb_packets+1); return err; } prev_toc = data[nb_packets][0]; nb_packets++; } // Output the final, partial packet. if (nb_packets > 0) { out_len = opus_repacketizer_out(rp, out, sizeof(out)); release_packets(data, nb_packets); if (out_len < 0) return (int)out_len; output_next_packet(out, out_len); }
An alternate way of merging packets is to simply call opus_repacketizer_cat() unconditionally until it fails. At that point, the merged packet can be obtained with opus_repacketizer_out() and the input packet for which opus_repacketizer_cat() needs to be re-added to a newly reinitialized repacketizer state.
|
|
|
Add a packet to the current repacketizer state. This packet must match the configuration of any packets already submitted for repacketization since the last call to opus_repacketizer_init(). This means that it must have the same coding mode, audio bandwidth, frame size, and channel count. This can be checked in advance by examining the top 6 bits of the first byte of the packet, and ensuring they match the top 6 bits of the first byte of any previously submitted packet. The total duration of audio in the repacketizer state also must not exceed 120 ms, the maximum duration of a single packet, after adding this packet. The contents of the current repacketizer state can be extracted into new packets using opus_repacketizer_out() or opus_repacketizer_out_range(). In order to add a packet with a different configuration or to add more audio beyond 120 ms, you must clear the repacketizer state by calling opus_repacketizer_init(). If a packet is too large to add to the current repacketizer state, no part of it is added, even if it contains multiple frames, some of which might fit. If you wish to be able to add parts of such packets, you should first use another repacketizer to split the packet into pieces and add them individually.
|
|
Allocates memory and initializes the new repacketizer with opus_repacketizer_init().
|
|
Frees an
|
|
Return the total number of frames contained in packet data submitted to the repacketizer state so far via opus_repacketizer_cat() since the last call to opus_repacketizer_init() or opus_repacketizer_create(). This defines the valid range of packets that can be extracted with opus_repacketizer_out_range() or opus_repacketizer_out().
|
|
Gets the size of an
|
|
(Re)initializes a previously allocated repacketizer state. The state must be at least the size returned by opus_repacketizer_get_size(). This can be used for applications which use their own allocator instead of malloc(). It must also be called to reset the queue of packets waiting to be repacketized, which is necessary if the maximum packet duration of 120 ms is reached or if you wish to submit packets with a different Opus configuration (coding mode, audio bandwidth, frame size, or channel count). Failure to do so will prevent a new packet from being added with opus_repacketizer_cat().
|
|
Construct a new packet from data previously submitted to the repacketizer state via opus_repacketizer_cat(). This is a convenience routine that returns all the data submitted so far in a single packet. It is equivalent to calling opus_repacketizer_out_range(rp, 0, opus_repacketizer_get_nb_frames(rp), data, maxlen)
|
|
Construct a new packet from data previously submitted to the repacketizer state via opus_repacketizer_cat().
|
For more information visit the Opus Website. |
©$year $generatedby doxygen 1.2.11.1 |