[第4波]幽魂系列汉化的有关资料

shane007

( L( Q" u8 a, V+ D' P9 g. P
最近找到了一些和幽魂系列Phantasmagoria 有关的资料，
$ `% R/ r4 y4 L也许将来可以用于汉化。

3 y+ }  G" l' T- @$ r: T和日文版有关的信息
, \8 k, R$ K6 \3 u# x) Mhttp://anthonylarme.tripod.com/phantas/phintgtp.html

相关工具
( T% Q2 K' q2 w2 Ahttp://anthonylarme.tripod.com/phantas/phcheats.html
-----------------------------------------------------------------------
. z3 T# U( F0 H8 ^2 B* M$ T2012/1/2  更新
# s# P2 J) y$ B! x& A3 Z) H关于幽魂游戏的字幕
4 ?$ f7 a2 L$ {# y1 q0 GPhantasmagoria subtitles function discovered - ScummVM :: Forums
3 @7 O3 ]# U9 o9 P- s  W: y; f7 c
VMD文件
Subtitling Sierra VMD Files | Breaking Eggs And Making Omelettes (multimedia.cx)VMD - MultimediaWiki
7 X" M5 [8 O' T0 X& l* l
字幕
Subtitling Sierra RBT Files | Breaking Eggs And Making Omelettes (multimedia.cx)

FFmpeg/subtitle-rbt.c at feature/VMD_encoder · multimediamike/FFmpeg · GitHub

1. /*
   + b/ g$ t: I& P1 d, O% r3 n
2. * subtitle-rbt.c
   
3. *  by Mike Melanson (mike -at- multimedia.cx)
   ( N7 C( u6 `& @8 \
4. *
   & s- L! E' a, d! L; F# o
5. * build with this command:
   
6. *   gcc -g -Wall subtitle-rbt.c -o subtitle-rbt -lm -lass
   8 H! M. H  H" h7 k0 a/ |: R
7. */
   & _1 F- f# Z; ~% \) r. l9 X# v! m
8. 
   
9. #include <inttypes.h>
   ; S* }9 \' r( i0 z  u; a, w7 L
10. #include <math.h>
    1 N) P2 i' S4 l/ L; [+ K  W. N# |
11. #include <stdio.h>
    8 s+ u* p# M% ~9 u$ Y  M
12. #include <stdlib.h>
    / C3 s5 J. k: F0 m1 C! x
13. #include <string.h>
    5 B9 C- ^( {2 T, j, g
14. 
    
15. #include <ass/ass.h>
      d& S" h: n2 X# G  N. E/ \
16. 
    " }: L4 ]" q# K* B* s8 [
17. #define LE_16(x) ((((uint8_t*)(x))[1] <<  8) | ((uint8_t*)(x))[0])
    
18. 
    & U8 |- @: _+ ?- Z
19. #define LE_32(x) (((uint32_t)(((uint8_t*)(x))[3]) << 24) |  \
    ' `4 P3 a9 y* }" b$ {
20.                              (((uint8_t*)(x))[2]  << 16) |  \
    
21.                              (((uint8_t*)(x))[1]  <<  8) |  \
    
22.                               ((uint8_t*)(x))[0])
    " W4 [) m( V, o" \& K
23. 
    
24. /*********************************************************************/
    
25. 
    , |$ ]; R+ k4 ^' u4 n
26. /* Bit reader stuff */
    
27. 
    
28. typedef struct
    ! \! t4 ~% Z6 S/ H$ }
29. {
    
30.     uint8_t *bytestream;
    2 [+ O) y% \, T. b
31.     int bytestream_size;
      F( s) d* A( |  q7 K. q
32.     int index;
    . |/ v- ?" Z6 r# `) a, x+ k, S6 X& D
33.     uint32_t bits;
    
34.     int bits_in_buffer;
    , s8 ?7 L: k( @5 W: [
35. } get_bits_context;
    
36. 
    ( G; Y' Q* z: U; r4 P4 }+ T
37. static inline void reload_bits(get_bits_context *gb)
    5 z$ A( a& O# m1 R* @6 z( e' ]1 |
38. {
    1 I8 v( X9 r& S- Y' z& w7 z8 z6 I8 T
39.     while (gb->bits_in_buffer <= 24)
    ' z. N$ Z+ t: s0 B" O
40.     {
    
41.         if (gb->index < gb->bytestream_size)
    
42.             gb->bits |= (gb->bytestream[gb->index++] << (24 - gb->bits_in_buffer));
    ! F6 e% ^( |! O# u5 F% _
43.         gb->bits_in_buffer += 8;
    . e# s( \" }( {9 L3 ?
44.     }
    
45. }
    
46. 
    . ]5 {) ~; S" w
47. static void init_get_bits(get_bits_context *gb, uint8_t *bytestream, int size)
    ' b, M, P, ?" Q
48. {
    : U4 v" X, K4 x) w& t- K' W
49.     gb->bytestream = malloc(size);
    & u& `1 I" r$ o9 _! Z
50.     memcpy(gb->bytestream, bytestream, size);
    . E6 e# s% C  a/ E* g2 M; i
51.     gb->bytestream_size = size;
    
52.     gb->index = 0;
    
53.     gb->bits = 0;
    / c6 T) g$ q& ^8 w0 J+ ]$ k1 U
54.     gb->bits_in_buffer = 0;
    / f, N/ S& {9 C. k' ^) `6 k
55. 
    
56.     reload_bits(gb);
    
57. }
    - E8 v; w+ S1 r- I! [
58. 
    
59. /* read bits without consuming them from the stream */
    
60. static int view_bits(get_bits_context *gb, int count)
    
61. {
    
62.     if (count >= 24)
    ( _. _  y$ y3 c7 o2 j) ^
63.         return -1;
    & ~7 Q6 R3 y' [
64.     if (gb->bits_in_buffer < count)
    
65.         reload_bits(gb);
    
66.     return (gb->bits >> (32 - count));
    
67. }
    $ N5 L5 d( |; P! T
68. 
    # Y3 h' I5 U0 H% P7 T3 n0 _
69. /* read and consume bits from the stream */
    
70. static int read_bits(get_bits_context *gb, int count)
    ; _: {: G' f% d+ b* P
71. {
      i8 u% K2 Y+ e: B# [2 c
72.     int value;
    , y" c$ B; G' S$ G
73. 
    
74.     if (count >= 24)
    0 r1 q- E( |8 w; [# h6 d$ U- O
75.         return -1;
    / u  N7 o. `0 l6 t$ R$ [$ R, o# p2 X9 S
76. 
    
77.     value = view_bits(gb, count);
    
78.     gb->bits <<= count;
    , ]+ C" l7 ^+ V- A
79.     gb->bits_in_buffer -= count;
      B0 E" U, R& w+ ~; x) w
80. 
    0 A0 W( A  {4 [- |- n7 ^! K
81.     return value;
    
82. }
    
83. 
    
84. static void delete_get_bits(get_bits_context *gb)
    
85. {
    
86.     free(gb->bytestream);
    , S1 @  F) X7 h
87. }
    $ N+ B2 l" [; `2 N
88. 
    ; z  s: o% I3 u9 x/ f& j
89. /*********************************************************************/
    - U) _4 H1 _" E: j
90. 
    0 B6 c2 q5 B  W- B6 v5 ~/ r
91. /* Bit writer stuff */
    6 z# K# z: K+ ^2 \/ z* f
92. 
    
93. #define MAX_PUT_BITS_BYTES 63000
    - o2 L. n4 h) N- Z  J
94. typedef struct
    
95. {
    8 f3 z5 ^% ~& s0 f
96.     uint8_t bytes[MAX_PUT_BITS_BYTES];
    
97.     int byte_index;
    
98.     uint32_t bit_buffer;
    
99.     int bits_buffered;
    - D- e9 d4 Y6 m/ f0 t
100. } put_bits_context;
     " }/ j; l# G2 z( @: {& f* h& m5 ~
101. 
     
102. static void reset_put_bits(put_bits_context *pb)
     3 B3 y+ ^, V* p7 X7 [% n
103. {
     8 \8 j: w" Y5 b+ f& o2 P
104.     memset(pb->bytes, 0, MAX_PUT_BITS_BYTES);
     ( t5 x4 z0 V0 R: T
105.     pb->byte_index = 0;
     
106.     pb->bit_buffer = 0;
     2 `7 q7 M* l- L- `& E, R7 a/ y
107.     pb->bits_buffered = 0;
     
108. }
     
109. 
     . C' `0 _/ I9 [4 s$ B/ f, n
110. static put_bits_context *init_put_bits()
     3 o9 X& N# c7 ~  T: {
111. {
     
112.     put_bits_context *pb;
     
113. 
     
114.     pb = malloc(sizeof(put_bits_context));
     ( m4 W! e7 N! F4 N3 m$ B( d6 J8 d1 A
115.     reset_put_bits(pb);
     
116. 
     
117.     return pb;
     $ b6 n: T1 g' X( S$ c/ Y# m
118. }
     
119. 
     7 Q# J! N( U& @
120. static void put_bits(put_bits_context *pb, int bits, int count)
     
121. {
     ( U" S; s' p3 ^9 x( y# u
122.     pb->bit_buffer <<= count;
     
123.     pb->bit_buffer |= (bits & (~(0xFFFFFFFF << count)));
     
124.     pb->bits_buffered += count;
     
125. 
     2 N7 x  y+ O% b1 s* \, o  s
126.     while (pb->bits_buffered >= 8)
     $ u9 n# u. j5 z1 m
127.     {
     ; c" [; j: n3 ~! r0 Q5 V
128.         pb->bytes[pb->byte_index++] = pb->bit_buffer >> (pb->bits_buffered - 8);
     8 Y* t, i) W0 l6 V$ X% l
129.         pb->bit_buffer &= (~(0xFFFFFFFF << (pb->bits_buffered - 8)));
     
130.         pb->bits_buffered -= 8;
     1 G0 @. z3 A& B7 H% b
131.     }
     2 j5 D' X$ J. Z5 r% C/ N4 g( g
132. 
     , ]8 }: `3 }4 X. p
133.     if (pb->byte_index >= MAX_PUT_BITS_BYTES)
     
134.     {
     + M8 @" @3 v; _. u" L
135.         printf("HELP! Bit overflow\n");
     
136.         exit(1);
     
137.     }
     + n  ~) \7 h/ X( f# M# t2 w0 l- F; F
138. }
     
139. 
     
140. static void put_bits_flush(put_bits_context *pb)
     
141. {
     
142.     if (pb->bits_buffered > 0)
     
143.         pb->bytes[pb->byte_index++] = pb->bit_buffer << (8 - pb->bits_buffered);
     3 z( `" M' J$ `; w/ h! k
144. }
     . \: F, o- i, `7 h. M7 Z# m  `/ j
145. 
     
146. static void delete_put_bits(put_bits_context *pb)
     $ l* u9 i, C9 r
147. {
     7 X) e+ G' ?% B( z+ Q/ |0 R7 |* R
148.     free(pb->bytes);
     6 J& h( |) P* Q4 e
149. }
     ! r) b" Q3 P% h
150. 
     . R: a/ P9 ]+ q. E
151. /*********************************************************************/
     
152. 
     ' J: k3 ]: v( d) e) t/ U( G) J8 E5 _
153. /* RBT functions */
     * |) p5 R: k( U, s4 `
154. 
     + e$ K+ @1 o' Z
155. #define PALETTE_COUNT 256
     
156. #define RBT_HEADER_SIZE 60
     " i# _4 k  `0 K
157. #define UNKNOWN_TABLE_SIZE (1024+512)
     
158. #define SUBTITLE_THRESHOLD 0x70
     
159. #define MILLISECONDS_PER_FRAME 100
     2 C. [6 O3 G) |- I" l% E
160. 
     ' C) }  X% p* o- i
161. /* VLC table */
     # V$ Z3 H) p- B/ L
162. #define VLC_SIZE 4
     , S6 b2 V3 t# d5 Y- d
163. static struct
     
164. {
       U5 _+ E+ |$ W" S* l
165.     int count;
     
166.     int value;
     
167. } lzs_vlc_table[] =
     
168. {
     & r: {5 D+ _+ M
169.     /* code length = 2 bits; value = 2 */
     
170.     /* 0000 */ { 2, 2 },
     0 Z7 k9 b' p" ~2 O% b  a: f5 \4 T
171.     /* 0001 */ { 2, 2 },
     
172.     /* 0010 */ { 2, 2 },
     ) s* K1 P+ E: l& u
173.     /* 0011 */ { 2, 2 },
     
174. 
     
175.     /* code length = 2 bits; value = 3 */
     
176.     /* 0100 */ { 2, 3 },
     
177.     /* 0101 */ { 2, 3 },
     
178.     /* 0110 */ { 2, 3 },
     # c8 C; Q) M# l: c9 z' g" b% _
179.     /* 0111 */ { 2, 3 },
     8 \$ r; Z& K) H/ Q
180. 
     6 r: [7 v: A- [$ V
181.     /* code length = 2 bits; value = 4 */
     
182.     /* 1000 */ { 2, 4 },
     
183.     /* 1001 */ { 2, 4 },
     1 `5 w2 L0 Z# }9 x- Y0 A
184.     /* 1010 */ { 2, 4 },
     
185.     /* 1011 */ { 2, 4 },
     
186. 
     
187.     /* code length = 4 bits; value = 5 */
     ; P% g6 G: D; L8 [
188.     /* 1100 */ { 4, 5 },
     
189. 
     7 T1 k( J% i0 {2 C9 g' J4 {( \! v: D5 L
190.     /* code length = 4 bits; value = 6 */
     
191.     /* 1101 */ { 4, 6 },
     6 K/ j  `% n, r1 R1 }$ F
192. 
     0 n3 F9 c/ z2 j3 Y
193.     /* code length = 4 bits; value = 7 */
     - `; Y, y) e5 b+ P4 Y8 [) h3 H0 K
194.     /* 1110 */ { 4, 7 },
     
195. 
     " w" O* C: R2 E0 A- }! L
196.     /* special case */
     
197.     /* 1111 */ { 4, 8 }
     . x& q& Q$ f5 M; A
198. };
     4 n* W8 E+ v) i( l( ?2 x, {2 b: Q
199. 
     
200. typedef struct
     
201. {
     ! r5 p' ~( h" l( |& ?- e
202.     int version;
     
203.     int width;
     , M0 n9 F. g7 T& u8 I6 Z% j( a
204.     int height;
     ! b$ Q# |( r8 J/ i6 \# x" I
205.     int frame_count;
     
206.     int audio_chunk_size;
     
207.     uint8_t palette[PALETTE_COUNT * 3];
     
208.     off_t video_frame_size_table_offset;
     
209.     uint8_t *video_frame_size_table;
     8 N; u6 J/ P% f' J, A2 ]5 G9 i  r
210.     off_t frame_size_table_offset;
     
211.     uint8_t *frame_size_table;
     % X* A/ v$ U, D& Q; l/ J+ H
212.     uint8_t *frame_load_buffer;
     % _9 j, P' h, @( v. B
213.     int dump_frames;
     3 }! B! s8 B! i$ S; E& b, |
214. 
     
215.     /* subtitle library */
     - H$ _0 q' r) b" d# L
216.     ASS_Library *ass_lib;
     
217.     ASS_Renderer *ass_renderer;
     
218.     ASS_Track *ass_track;
     / m/ q1 g, [- B, |: h# f
219. } rbt_dec_context;
     
220. 
     2 b9 J7 z; I: h9 M  b9 b9 \
221. static void dump_pnm_file(char *filename, rbt_dec_context *rbt,
     0 {5 n  C# j" u; a
222.     uint8_t *image, int width, int height)
     
223. {
     0 [  `4 \$ I7 f# z* L) F( A
224.     FILE *outfile;
     2 L, j+ a: C* ~$ M" @, Q0 X
225.     uint8_t bytes[3];
     + T: ?: _1 j1 M# G$ P
226.     int p;
     
227.     uint8_t pixel;
     % r! Z; D9 q7 I+ a) e8 I  K$ g. u8 i+ ^
228. 
     
229.     outfile = fopen(filename, "wb");
     
230.     fprintf(outfile, "P6\n%d %d\n255\n", width, height);
     . k) K7 g! W' x
231.     for (p = 0; p < width * height; p++)
     0 p2 X6 i+ w. [# t; d# S8 {
232.     {
     
233.         pixel = image[p];
     
234.         bytes[0] = rbt->palette[pixel*3+0];
     
235.         bytes[1] = rbt->palette[pixel*3+1];
     3 T7 }5 z% g9 Z( k$ r. S" {5 g' d
236.         bytes[2] = rbt->palette[pixel*3+2];
     
237.         fwrite(bytes, 3, 1, outfile);
     . }. j- a. w1 U" U
238.     }
     
239.     fclose(outfile);
     
240. }
     
241. 
     * t( G( H5 r0 p9 K, G: a
242. static int load_and_copy_rbt_header(rbt_dec_context *rbt, FILE *inrbt_file, FILE *outrbt_file)
     
243. {
     
244.     uint8_t header[RBT_HEADER_SIZE];
     
245.     int palette_data_size;
     + ^/ I4 l  |" |" c7 ^
246.     uint8_t *palette_chunk;
     ( \: O! ^4 V; k& V
247.     int unknown_chunk_size;
     - E5 @0 B  Y" `( T7 h; D
248.     uint8_t *unknown_chunk;
     
249.     uint8_t unknown_table[UNKNOWN_TABLE_SIZE];
     ) C) c. v( {# W3 ]" x
250.     off_t padding_size;
     8 K/ ]. {, d, G
251.     uint8_t *padding;
     
252.     int i;
     
253.     int frame_size;
     
254.     int max_frame_size;
     * Q* ^7 j' S  |' |7 \1 o# @' q
255.     int first_palette_index;
     
256.     int palette_count;
     # J! l# A5 i: G' a* ~# `
257.     int palette_type;
     $ Q3 j& P% ^7 n4 R) u# @4 a9 }
258.     int palette_index;
     
259. 
     
260.     fseek(inrbt_file, 0, SEEK_SET);
     9 b8 G+ `  R+ g  Y! E5 t
261.     fseek(outrbt_file, 0, SEEK_SET);
     
262. 
     . w2 o  r5 n# A  P4 O# d3 e- j
263.     /* load the header */
     
264.     if (fread(header, RBT_HEADER_SIZE, 1, inrbt_file) != 1)
     0 _- n% H1 e& @- y* c) T5 M
265.     {
     
266.         printf("problem reading initial RBT header\n");
     
267.         return 0;
     
268.     }
     
269. 
     . [1 K5 y0 X+ C
270.     /* copy header to the output */
     ! Z. u, l8 y4 f( r
271.     if (fwrite(header, RBT_HEADER_SIZE, 1, outrbt_file) != 1)
     / n4 T* M9 n" M
272.     {
     0 v9 n/ C, v5 R; e6 H6 `5 \7 @5 M
273.         printf("problem writing initial RBT header\n");
     
274.         return 0;
     
275.     }
     & \9 x! \! f. |) {
276. 
     ) j; A3 m0 l8 l+ Y8 u# H
277.     rbt->version = LE_16(&header[6]);
     
278.     rbt->audio_chunk_size = LE_16(&header[8]);
     
279.     rbt->frame_count = LE_16(&header[14]);
     
280. 
     8 Y  k. @- C" P3 ^5 ^
281.     /* transfer the unknown data, if it's there */
     & R: ~4 I9 I0 e0 ^! J" q6 O6 \# r* ^3 E
282.     unknown_chunk_size = LE_16(&header[18]);
     
283.     if (unknown_chunk_size > 0)
     % L* f6 A" `4 R
284.     {
     
285.         unknown_chunk = malloc(unknown_chunk_size);
     * B6 Z, f# A& w0 g( n
286.         if (fread(unknown_chunk, unknown_chunk_size, 1, inrbt_file) != 1)
     
287.         {
     5 M4 S' @% r1 ^
288.             printf("problem reading unknown data\n");
     
289.             return 0;
     6 e* E* `/ z) \& v
290.         }
     
291.         if (fwrite(unknown_chunk, unknown_chunk_size, 1, outrbt_file) != 1)
     - `+ u, w( z% I5 c8 f; @
292.         {
     
293.             printf("problem writing unknown data\n");
     
294.             return 0;
     
295.         }
     
296.         free(unknown_chunk);
     
297.     }
     
298. 
     2 F' y8 h( W. W5 Y% ~! L
299.     /* transfer the palette chunk */
     
300.     palette_data_size = LE_16(&header[16]);
     
301.     palette_chunk = malloc(palette_data_size);
     
302.     if (fread(palette_chunk, palette_data_size, 1, inrbt_file) != 1)
     ! P# Q) C  g- g0 ]2 i
303.     {
     2 J- m! c  E+ l+ h  I
304.         printf("problem reading palette\n");
     ' u% A0 J9 H& l+ x( e( G
305.         return 0;
     
306.     }
     
307.     if (fwrite(palette_chunk, palette_data_size, 1, outrbt_file) != 1)
     
308.     {
     
309.         printf("problem writing palette\n");
     ; Z. b' G7 s: `) G, o
310.         return 0;
     " v9 k; G0 \! F0 F4 {, n3 o
311.     }
     % v8 S* U5 w+ k2 b
312.     /* load the palette into the internal context */
     1 l; F  f* _8 t1 @
313.     memset(rbt->palette, 0, PALETTE_COUNT * 3);
     7 N9 p6 C6 G: |+ Y
314.     first_palette_index = palette_chunk[25];
     ' E6 o4 M: S9 `
315.     palette_count = LE_16(&palette_chunk[29]);
     
316.     palette_type = palette_chunk[32];
     * S4 o! ^9 o$ Q3 a1 j
317.     palette_index = (palette_type == 0) ? 38 : 37;
     
318.     for (i = first_palette_index; i < first_palette_index + palette_count; i++)
     * h$ a: |5 {  {. ^5 c
319.     {
     , g2 L1 ]4 D- S
320.         rbt->palette[i*3+0] = palette_chunk[palette_index++];
     & I- s" E$ C6 ^( x- N
321.         rbt->palette[i*3+1] = palette_chunk[palette_index++];
     % G7 [" D( \; A" x, j3 u
322.         rbt->palette[i*3+2] = palette_chunk[palette_index++];
     
323.     }
     & G4 i; [+ T( u2 Y$ _: T
324.     free(palette_chunk);
     
325. 
     
326.     /* copy the video frame size table (2 bytes per frame), as a placeholder */
     
327.     rbt->video_frame_size_table = malloc(rbt->frame_count * sizeof(uint16_t));
     & o& _; p+ R- l9 f& `2 t, ?/ m7 R8 F8 e7 W
328.     if (fread(rbt->video_frame_size_table, rbt->frame_count * sizeof(uint16_t), 1, inrbt_file) != 1)
     # p- l+ t5 j1 V5 O& X
329.     {
     ! Q* ~; c# K) V% [6 E
330.         printf("problem reading frame table\n");
     
331.         return 0;
     
332.     }
     
333.     rbt->video_frame_size_table_offset = ftell(outrbt_file);
     
334.     if (fwrite(rbt->video_frame_size_table, rbt->frame_count * sizeof(uint16_t), 1, outrbt_file) != 1)
     8 m7 s6 h8 u9 O; {) X% @
335.     {
     
336.         printf("problem writing frame table\n");
     ) E+ _7 E9 E. w8 {1 ]  F
337.         return 0;
     & a  F( N3 g! l- j, r  r
338.     }
     
339. 
     
340.     /* copy the frame size table (2 bytes per frame), as a placeholder */
     ; r5 S9 S4 X0 L1 i. B8 Q0 \
341.     rbt->frame_size_table = malloc(rbt->frame_count * sizeof(uint16_t));
     % Z! x) `, L2 v: ~# l
342.     if (fread(rbt->frame_size_table, rbt->frame_count * sizeof(uint16_t), 1, inrbt_file) != 1)
     
343.     {
     
344.         printf("problem reading frame table\n");
     5 Q' m) g8 t- k. K9 i9 E# I7 ~
345.         return 0;
     # O# F) o) N! y
346.     }
     
347.     rbt->frame_size_table_offset = ftell(outrbt_file);
     6 }7 u- q' C: T5 w+ f3 Y
348.     if (fwrite(rbt->frame_size_table, rbt->frame_count * sizeof(uint16_t), 1, outrbt_file) != 1)
     
349.     {
     % ]! K. a+ q# A) [6 S
350.         printf("problem writing frame table\n");
     8 W, H5 a' O0 U8 z; e$ \% ^
351.         return 0;
     , h2 D, j! a$ O: E" @, t5 q+ ]1 H
352.     }
     
353. 
     
354.     /* find the max frame size */
     * M' S/ u3 z' j+ {8 ~* O5 t
355.     max_frame_size = 0;
     / _5 @- }  L$ ]0 P
356.     for (i = 0; i < rbt->frame_count; i++)
     7 c, D4 A1 L7 w7 M. D! C8 E
357.     {
     , b* Z4 m; T8 i2 q3 ]% s
358.         frame_size = LE_16(&rbt->frame_size_table[i*2]);
     8 V. B, F, J3 d. u: I
359.         if (frame_size > max_frame_size)
     
360.             max_frame_size = frame_size;
     
361.     }
     
362.     rbt->frame_load_buffer = malloc(max_frame_size);
     
363. 
     
364.     /* transfer the unknown table(s) */
     5 C7 l, E9 O3 T0 f/ u6 W& B
365.     if (fread(unknown_table, UNKNOWN_TABLE_SIZE, 1, inrbt_file) != 1)
     1 e9 m9 R/ S) `* Z
366.     {
     % B  r- _8 e) l* p, w
367.         printf("problem reading unknown table\n");
     
368.         return 0;
     
369.     }
     % _/ H4 q/ i! O" H# a
370.     if (fwrite(unknown_table, UNKNOWN_TABLE_SIZE, 1, outrbt_file) != 1)
     
371.     {
     & ^; a+ I) |2 b/ g* J/ h! R
372.         printf("problem writing unknown table\n");
     
373.         return 0;
     
374.     }
     
375. 
     ; I- l/ x& @; ~0 o
376.     /* copy over padding */
     $ l, [# D* G$ t7 j# F6 d- T  h
377.     padding_size = 0x800 - (ftell(inrbt_file) & 0x7FF);
     
378.     if (padding_size)
     7 z9 Q6 i  h2 O) i# f% q+ C
379.     {
     & U# s* O( }! X9 [
380.         padding = malloc(padding_size);
     
381.         if (fread(padding, padding_size, 1, inrbt_file) != 1)
     6 T. r- [# r6 i
382.         {
     
383.             printf("problem reading padding\n");
     
384.             return 0;
     
385.         }
     
386.         if (fwrite(padding, padding_size, 1, outrbt_file) != 1)
     0 M1 r" p& l4 o
387.         {
     
388.             printf("problem writing padding\n");
     2 u8 o# y$ L# Z" C: f
389.             return 0;
     ' E: P; D! p2 r" q) D
390.         }
     / {' N' y3 a( Q  E. C& O3 P& P) r
391.         free(padding);
     1 a. Z/ W! i6 |" Z2 I
392.     }
     3 t2 A$ ^5 C. @* ~9 M
393. 
     8 M, F/ |5 I# B
394.     return 1;
     
395. }
     
396. 
     4 C8 d3 b' q/ h/ h* a
397. static int get_lzs_back_ref_length(get_bits_context *gb)
     
398. {
     ' u/ |& a$ g: Q; q
399.     int vlc;
     $ P, i% O) k  q7 c3 U2 w& G# c
400.     int count;
     
401.     int value;
     
402. 
     
403.     vlc = view_bits(gb, VLC_SIZE);
     0 E6 J/ c8 r, k! D# s4 K' f  a) H8 r
404.     count = lzs_vlc_table[vlc].count;
     $ F. q4 a8 M9 j- u4 R
405.     value = lzs_vlc_table[vlc].value;
     
406. 
     ! E) E2 }6 \0 Q. W
407.     read_bits(gb, count);
     & l; B, Z/ y9 S3 X5 p) {
408.     if (value == 8)
     
409.     {
     " r( c8 F1 p3 g; z, [
410.         do
     ! k: T8 i2 z6 S; K0 q: b
411.         {
     7 d, Z( W1 ~# K8 G7 K
412.             vlc = read_bits(gb, VLC_SIZE);
     
413.             value += vlc;
     
414.         }
     0 j. c% }0 S- e1 E' D" B2 n
415.         while (vlc == 0xF);
     $ @8 }& g$ L- X. h6 g/ A/ L
416.     }
     , n+ ]1 V( b  h( j
417. 
     ( y; m6 A1 O' J$ k
418.     return value;
     
419. }
     
420. 
     8 W4 D; y( p) B0 J9 o
421. static void compress_window(put_bits_context *pb, uint8_t *full_window,
     
422.     int full_window_stride,
     
423.     int window_top, int window_bottom, int window_left, int window_right)
     
424. {
     7 Y- f" \; {# H, e3 U
425.     int last_pixel;
     : A5 a7 H+ l! s/ X- N5 Z
426.     int run_size;
     0 a: u. _- _/ g4 U& q# t
427.     int x;
     1 i( f3 M$ j. T) {7 ]  O" f
428.     int y;
     6 T/ B! A1 @( g+ N) c7 P# S
429.     int start_index;
     * ~. w. G1 B% G- y
430.     int end_index;
     
431.     int encode_last_run;
     
432. 
     9 D' t) {% ^6 D$ m) X" P2 b5 A0 \/ ]
433.     last_pixel = full_window[0];
     
434.     run_size = 1;
     
435.     for (y = window_top; y <= window_bottom; y++)
     ' F* l6 G- y0 w5 k; a* G- Q& L
436.     {
     1 O: F% G# V9 f6 z0 c6 v- D
437.         start_index = y * full_window_stride + window_left;
     
438.         if (y == window_top)
     / o/ q  k4 t$ f# Q, i9 j
439.             start_index += 1;
     : _0 X  x5 Q9 C0 I
440.         end_index = y * full_window_stride + window_right;
     
441.         if (y == window_bottom)
     
442.             encode_last_run = 1;
     
443.         else
     
444.             encode_last_run = 0;
     2 |. D6 m$ |8 b, U
445.         for (x = start_index; x < end_index; x++)
     8 ~9 W. r* |' L+ d* w6 D
446.         {
     % T1 L8 g3 v# Z5 L4 x- e
447.             if (!encode_last_run && full_window[x] == last_pixel)
     
448.                 run_size++;
     4 n, I+ }9 \, G0 `+ R
449.             else
     0 Z( X" ^5 c( u2 X1 ~' r
450.             {
     
451.                 if (run_size == 1)
     
452.                 {
     9 \) S. ]6 b9 P7 B0 d+ Q- J
453.                     /* encode a 0 bit followed by raw pixel byte */
     ' R! I3 j- C6 I% Q
454.                     put_bits(pb, 0, 1);
     - B6 q8 T1 X) p+ X  e
455.                     put_bits(pb, last_pixel, 8);
     : ^- G& j, c/ c9 p* T
456.                 }
     & i$ x$ P" [# D) p$ x/ F
457.                 else if (run_size == 2)
       C$ d; K# f0 c1 u
458.                 {
     / ^8 L/ T" E* C. a: K, s
459.                     /* encode a 0 bit followed by raw pixel byte */
     7 C+ l' Q" f* ~0 E! T* @
460.                     put_bits(pb, 0, 1);
     " e' o! q$ J4 h& b, q. G( w
461.                     put_bits(pb, last_pixel, 8);
     5 j$ y) j; e3 c9 B( V- `
462.                     put_bits(pb, 0, 1);
     9 R5 V' H# u% r) j% d
463.                     put_bits(pb, last_pixel, 8);
     % X6 Q# m( `) Q4 |4 v
464.                 }
     
465.                 else
     0 q! Y% A6 r& ?
466.                 {
     % X) G/ ~2 E0 h3 @3 f$ ?; E+ W
467.                     /* encode a 0 bit followed by raw pixel byte */
     
468.                     put_bits(pb, 0, 1);
     
469.                     put_bits(pb, last_pixel, 8);
     
470.                     run_size--;
     
471.                     /* encode a run: a 1 bit, followed by a back reference
     2 }+ q$ @2 e" J1 q" M
472.                      * offset (-1), followed by a length */
     
473.                     put_bits(pb, 1, 1);
     
474.                     put_bits(pb, 1, 1);  /* 1 = 7-bit offset */
     # \, p. M  _. _# n$ ]3 R4 }
475.                     put_bits(pb, 1, 7);
     
476.                     if (run_size <= 4)
     
477.                     {
     
478.                         /* lengths 2, 3, and 4 are 2 bits */
     
479.                         put_bits(pb, run_size - 2, 2);
     4 @: ^& a/ u( n3 r8 k
480.                     }
     
481.                     else if (run_size <= 7)
     3 k/ G. W) a3 d
482.                     {
     ! \) k' H1 n8 D9 y
483.                         /* lengths 5, 6, and 7 are 4 bits */
     - G3 }0 F+ H. l$ T2 Z$ T5 ?6 }8 [7 J) q
484.                         put_bits(pb, run_size + 7, 4);
     
485.                     }
     5 T# H( Z$ a/ G8 `+ ^
486.                     else
     0 H% q2 b4 y" M' `3 K
487.                     {
     7 ]  ^- c7 o* D% W/ I
488.                         /* arbitrary length; start by encoding 0xF which
     3 O7 b9 y4 W3 d( K
489.                          * stands in for an initial version of 8 */
     6 M7 ^/ a" T1 o( }- s. j8 H
490.                         put_bits(pb, 0xF, 4);
     + K8 ^' ]; X8 c* ^9 b# x
491.                         run_size -= 8;
     ; I& D. y& w8 B9 X8 J1 Z/ ~
492. 
     
493.                         /* encode blocks of 4 bits until run_size is 0 */
     
494.                         while (run_size >= 0)
     " p  c; J* B2 L- V
495.                         {
     % T  D+ {7 i# H* ^
496.                             if (run_size >= 15)
     
497.                             {
     " p( c" |7 t0 L5 D) P% h9 W2 N
498.                                 put_bits(pb, 0xF, 4);
     " h4 Q: `$ s, S. V2 h5 f
499.                                 run_size -= 0xF;
     
500.                             }
     0 L$ ]) m& l/ Z! M! A
501.                             else
     
502.                             {
     
503.                                 put_bits(pb, run_size, 4);
     
504.                                 run_size = -1;
     
505.                             }
     6 u* |( m9 V) q( k/ u& x
506.                         }
     * S; `* @8 g& \5 u
507.                     }
     
508.                 }
     ( N; i, @7 F9 q4 U. V1 b! d
509. 
     
510.                 last_pixel = full_window[x];
     7 n2 }; a' f2 {" e* j: {
511.                 run_size = 1;
     
512. 
     4 |) N1 n& g5 W! B
513.                 /* this single x iteration was only here to close the final run */
       f- c& O1 t6 M! P
514.                 if (y == window_bottom)
     4 t; g  N9 K6 p3 e; M& n8 q
515.                     break;
     . j* l1 E4 l4 ]# u. w
516.             }
     $ E) ]$ G& B, a0 @
517.         }
     
518.     }
     
519. 
     
520.     /* close the bitstream by encoding a back reference with length 0 */
     
521.     put_bits(pb, 1, 1);  /* back reference run */
     
522.     put_bits(pb, 1, 1);  /* 1 = 7-bit offset */
     
523.     put_bits(pb, 0, 7);  /* length 0 */
       R6 f4 f) x1 K6 G& H3 y( R
524. 
     
525.     put_bits_flush(pb);
     ; }" _& p6 q8 ^
526. }
     
527. 
     
528. /* compute Euclidean distance between an RGB color and the desired target */
     
529. static int compute_rgb_distance(int r1, int r2, int g1, int g2, int b1, int b2)
     " x4 u8 M" S5 T# P& h
530. {
     : o- O( a6 M' k' [8 c
531.     return sqrt((r1 - r2) * (r1 - r2) +
     / j+ h2 O4 i: Q( E
532.                 (g1 - g2) * (g1 - g2) +
     
533.                 (b1 - b2) * (b1 - b2));
     / h0 b2 f# s1 P5 J  l
534. }
     
535. 
     
536. static uint8_t find_nearest_color(rbt_dec_context *rbt, int r, int g, int b)
     . C5 d8 S1 M8 h
537. {
     - T2 F1 O+ a1 o' c( B7 U
538.     int i;
     
539.     int nearest_distance;
     
540.     int distance;
     1 l: X: H( r* l/ ]
541.     int rp;
     
542.     int gp;
     
543.     int bp;
     
544.     uint8_t palette_index;
     * I9 _! I$ G6 H1 I$ P& \
545. 
     
546.     nearest_distance = 999999999;
     
547.     palette_index = 0;
     
548.     for (i = 0; i < 256; i++)
     . S% U  @9 G) J
549.     {
     . O6 [3 o: g1 B5 ^$ k- c4 c. Y
550.         rp = rbt->palette[i * 3 + 0];
     
551.         gp = rbt->palette[i * 3 + 1];
     8 _# _4 i# g9 S; C8 U+ Y  v7 @3 R
552.         bp = rbt->palette[i * 3 + 2];
     
553.         distance = compute_rgb_distance(r, rp, g, gp, b, bp);
     7 h5 P6 R0 g3 p, r4 A7 c: q
554.         if (distance < nearest_distance)
     
555.         {
     3 v6 R6 R  F' k
556.             nearest_distance = distance;
     & T" M; Y" z1 f8 g+ W
557.             palette_index = i;
     
558.         }
     
559.         /* can't get closer than 0; break early */
     0 U9 J$ Z6 E7 F! b& C, Z
560.         if (distance == 0)
     3 i! F! Q6 |* N8 y& @+ E" a& R/ g
561.             break;
     * Q& i* s  R& F, b' t. V: E
562.     }
     7 m5 Z! N* X$ ?' c" @! @" d/ y
563. 
     6 `# F, m% v$ q
564.     return palette_index;
     
565. }
     
566. 
     
567. static void subtitle_frame(rbt_dec_context *rbt, uint8_t *frame,
     5 h$ A( h! k. `' _7 H
568.     int width, int height, int timestamp)
     : y8 Q$ K+ {8 y: J4 U
569. {
     + a/ ]4 Y# z; l+ p( ^2 C1 f/ ~& `. @
570.     ASS_Image *subtitles;
     ! h4 P; T% q, P" a
571.     int detect_change;
     7 v( P, k, m6 T) E; t, @# A
572.     uint8_t subtitle_pixel;
     " I7 N% q6 J' c% K1 g
573.     int x, y;
     + k0 s" I7 k" v( H  u
574.     uint8_t *frame_ptr;
     
575.     uint8_t *subtitle_ptr;
     5 w1 k4 z; `  G2 O: ?9 a
576. 
     
577.     /* ask library for the subtitle for this timestamp */
     
578.     subtitles = ass_render_frame(rbt->ass_renderer, rbt->ass_track,
     
579.         timestamp, &detect_change);
     & _! |: y: k! Z* I
580. 
     
581.     /* render the list of subtitles onto the decoded frame */
     2 F; q9 k1 ]4 m0 ]  H
582.     while (subtitles)
     - j! y/ y, T  s/ m: x
583.     {
     $ {7 E9 P% ~' w; ?* t: Q1 F
584.         /* palette components are only 6 bits, so shift an extra 2
     8 A" ]( G5 o6 `: m3 }/ B; _! _5 `  w
585.          * bits off each component */
     5 m2 c% w7 S5 n8 L) M% X, [
586.         subtitle_pixel = find_nearest_color(rbt,
     
587.             (subtitles->color >> 10) & 0xFF,
     
588.             (subtitles->color >> 18) & 0xFF,
     
589.             (subtitles->color >> 26) & 0xFF);
     
590.         for (y = 0; y < subtitles->h; y++)
     
591.         {
     
592.             subtitle_ptr = &subtitles->bitmap[y * subtitles->stride];
     " y* \* o. }. ^
593.             frame_ptr = &frame[(subtitles->dst_y + y) * width + subtitles->dst_x];
     / {& T7 Q- J& Z) J5 |5 U
594.             for (x = 0; x < subtitles->w; x++, frame_ptr++, subtitle_ptr++)
     
595.             {
     % W' g2 \2 T" [% L! q
596.                 if (*subtitle_ptr >= SUBTITLE_THRESHOLD)
     
597.                     *frame_ptr = subtitle_pixel;
     / D( L2 U0 U9 T1 G; G
598.             }
     & x' r3 h* h' h9 M  f+ g
599.         }
     ) E3 d% G+ s5 J9 ~
600.         subtitles = subtitles->next;
     
601.     }
     
602. }
     
603. 
     + ^2 B/ }) I1 p* [
604. static int copy_frames(rbt_dec_context *rbt, FILE *inrbt_file, FILE *outrbt_file,
     & V# Q, F. L3 S" j+ _
605.     int origin_x, int origin_y, int window_width, int window_height)
     5 s6 _( {0 R$ n
606. {
     + y  j$ H- h8 f+ P/ T, i
607.     int i;
     ; o* o) Y. w# w( A2 P
608.     int j;
     . v2 s' h; o4 J, {7 y/ s$ `* N
609.     int scale;
     6 o7 M2 m" A7 Q7 R8 B8 ?) y
610.     int width;
     8 L# s  N4 {; X! m) v
611.     int height;
     
612.     int max_width;
     
613.     int max_height;
     * Z( K1 `) [# b. b: @
614.     int frame_x;
     3 D* Y) K0 G% I/ O) C& |
615.     int frame_y;
     % {2 N0 H- T6 f% Q! z- D
616.     int fragment_count;
     
617.     int decoded_size;
     
618.     uint8_t *decoded_frame;
     
619.     int fragment;
     
620.     int fragment_compressed_size;
     . B7 H" p! g8 Q; c5 w8 t( K3 P
621.     int fragment_decompressed_size;
     5 t0 T, z) \- l* o
622.     int compression_type;
     9 ]# A! @6 w! K
623.     int index;
     
624.     int out_index;
     
625.     get_bits_context gb;
     
626.     int frame_size;
     
627.     int video_frame_size;
     
628.     int audio_frame_size;
     ; v/ @" E" o( A- h) v7 ]8 [$ B
629. 
     
630.     int back_ref_offset_type;
     
631.     int back_ref_offset;
     # v& B1 J- P6 H: }
632.     int back_ref_length;
     
633.     int back_ref_start;
     ; N# z# F1 Q  O/ W* X
634.     int back_ref_end;
     
635. 
     
636.     uint8_t *full_window;
     
637.     int full_window_size;
     
638.     int y;
     3 F- {0 M: G" S! z, z3 {
639.     int window_top;
     0 c$ V% }5 j% `5 |, \& H! Z) ?
640.     int window_bottom;
     
641.     int window_left;
     
642.     int window_right;
     $ o6 W" `8 H3 p' `
643.     int window_size;
     2 Y( S4 R' a1 w; ?) r( w$ x
644. 
     
645.     char filename[30];
     
646. 
     4 S* ?1 t5 a0 y6 c' P, g5 b. v
647.     put_bits_context *pb;
     
648. 
     * I" }; Q" e4 i( H) ^% B0 G
649.     full_window_size = window_width * window_height;
     
650.     full_window = malloc(full_window_size);
     6 ~0 N. O/ O3 |  n: o: ?9 ^8 S
651.     pb = init_put_bits();
     
652. 
     0 G. H8 S4 I5 b  Z: S
653.     max_width = 0;
     
654.     max_height = 0;
     
655. 
     
656.     for (i = 0; i < rbt->frame_count; i++)
     # i+ q: e5 o7 u2 @* S9 ^: v+ {
657.     {
     
658.         /* read the entire frame (includes audio and video) */
     
659.         frame_size = LE_16(&rbt->frame_size_table[i*2]);
     
660.         video_frame_size = LE_16(&rbt->video_frame_size_table[i*2]);
     
661.         audio_frame_size = frame_size - video_frame_size;
     : J; F9 M" W* m# E: m7 ?
662.         if (fread(rbt->frame_load_buffer, frame_size, 1, inrbt_file) != 1)
     3 P# E7 G" r5 Z7 ]
663.         {
     $ F% f5 \$ B7 J+ m
664.             printf("problem reading frame %d\n", i);
     8 _% a( z6 b) I. @* v  y, [
665.             return 0;
     
666.         }
     
667. 
     0 m8 q* l2 w. E% t! x) h
668.         scale = rbt->frame_load_buffer[3];
       U3 U8 R3 S' f* i* d: ?* [9 \
669.         width = LE_16(&rbt->frame_load_buffer[4]);
     ' M# J) k! H- ?- ?
670.         if (max_width < width)
     ' ?& i/ K: i' l5 ]; X
671.             max_width = width;
     ; C0 x  W( p( h$ s9 d5 q4 L
672.         if (max_height < height)
     
673.             max_height = height;
     
674.         height = LE_16(&rbt->frame_load_buffer[6]);
     
675.         frame_x = LE_16(&rbt->frame_load_buffer[12]);
     5 k( Z& b$ w8 b' ^7 N
676.         frame_y = LE_16(&rbt->frame_load_buffer[14]);
     
677.         fragment_count = LE_16(&rbt->frame_load_buffer[18]);
     " B% Z/ u2 ]( x, F
678.         decoded_size = width * height;
     
679. 
     
680.         printf("processing frame %d: %d%%, %dx%d, origin @ (%d, %d), %d fragments\n", i, scale, width, height, frame_x, frame_y, fragment_count);
     - I7 f, A: E2 u  |& p
681. 
     5 f  e8 W4 l6 K1 `% r! c
682.         /* decode the frame */
     3 [4 C( [0 N. A. J' [2 G4 r) ^
683.         decoded_frame = malloc(decoded_size);
     
684.         index = 24;
     ) y3 Z  ^' c2 ~6 \& l
685.         out_index = 0;
     
686.         for (fragment = 0; fragment < fragment_count; fragment++)
     " r# z" z9 U) E
687.         {
     
688.             fragment_compressed_size = LE_32(&rbt->frame_load_buffer[index]);
     0 {4 T7 n/ z6 e3 E3 V- H
689.             index += 4;
     8 m2 _, T9 l$ z2 N8 ^& v4 E1 }4 ^
690.             fragment_decompressed_size = LE_32(&rbt->frame_load_buffer[index]);
     4 P7 ]% ~) T  P9 H8 t) {
691.             index += 4;
     9 r. M( g  j2 `+ q2 i5 }& B
692.             compression_type = LE_16(&rbt->frame_load_buffer[index]);
     
693.             index += 2;
     
694. 
     ' x! O4 K9 E: B, y
695.             if (compression_type == 0)
     
696.             {
     
697.                 init_get_bits(&gb, &rbt->frame_load_buffer[index],
     , v9 M) N* X6 }" D9 v
698.                     fragment_compressed_size);
     0 t: C% J% r6 n! ]# N* F
699. 
     
700.                 while (out_index < fragment_decompressed_size)
     4 H/ ~' x# x6 J
701.                 {
     
702.                     if (read_bits(&gb, 1))
     
703.                     {
     8 @; D* d) ^3 A' T! \' Z
704.                         /* decode back reference offset type */
     
705.                         back_ref_offset_type = read_bits(&gb, 1);
     
706. 
     
707.                         /* back reference offset is 7 or 11 bits */
     ( [6 K( M1 C9 e2 a- G0 X
708.                         back_ref_offset = read_bits(&gb,
     
709.                             (back_ref_offset_type) ? 7 : 11);
     * i; i4 L/ t: o- O, D0 d  ]
710. 
     , [; d& Z* e& Z6 `( e8 {
711.                         /* get the length of the back reference */
     
712.                         back_ref_length = get_lzs_back_ref_length(&gb);
     
713.                         back_ref_start = out_index - back_ref_offset;
     
714.                         back_ref_end = back_ref_start + back_ref_length;
     
715. 
     ' D+ Y! s5 }7 j. a8 k' n! D
716.                         /* copy the back reference, byte by byte */
     : K5 N" z4 b' M% Q* J! x: r6 \
717.                         for (j = back_ref_start; j < back_ref_end; j++)
     
718.                             decoded_frame[out_index++] = decoded_frame[j];
     3 @/ K7 [2 G- G& Q  n
719.                     }
     
720.                     else
     
721.                     {
     
722.                         /* read raw pixel byte */
     1 y  {: K  l4 ~: @6 z! @
723.                         decoded_frame[out_index++] = read_bits(&gb, 8) & 0xFF;
     . l4 y* W1 \' z7 H% a! _
724.                     }
     
725.                 }
     & ?7 F2 W1 s  C& |6 u. y6 i% S
726. 
     
727.                 delete_get_bits(&gb);
     % x# \; q7 ?( ?6 k/ h' Q9 D9 |
728.             }
     
729. 
     ( V5 G" Q; w7 K# @& Z
730.             /* next fragment */
     
731.             index += fragment_compressed_size;
     + e2 i% `, m2 K- g( }
732.         }
     1 w  b- i7 y) \* v7 |/ L
733. 
     . V4 J# h5 Y9 O) I2 f" Y9 Y
734.         if (rbt->dump_frames)
     
735.         {
     
736.             /* dump the original frame */
     
737.             sprintf(filename, "original-frame-%03d.pnm", i);
     
738.             dump_pnm_file(filename, rbt, decoded_frame, width, height);
     2 h4 ^! t# ?1 {' O* e1 ~
739.         }
     
740. 
     0 f0 F4 b, ~" i( n+ {1 [9 N! Y0 Z! u
741.         /* transfer the image onto the frame window */
     
742.         memset(full_window, 0xFF, full_window_size);
     6 i3 U8 n' G2 h# P- Z
743.         index = 0;
     + x' L! g7 T2 j8 O. a
744.         for (y = 0; y < height; y++)
     8 f4 W- n4 N2 P
745.         {
     
746.             out_index = window_width * (frame_y + y) + frame_x;
     
747.             memcpy(&full_window[out_index], &decoded_frame[index], width);
     # v3 t/ d- j0 l3 I0 f/ l, w( _
748.             index += width;
     
749.         }
     ( ~0 `3 T/ Q0 J5 [  p, d2 `
750. 
     
751.         /* write the subtitle */
     1 ?  r: e; N7 B  A) U; t% k9 X5 x
752.         subtitle_frame(rbt, full_window, window_width, window_height,
     - q; S9 o$ V4 P) n; g
753.             i * MILLISECONDS_PER_FRAME);
     
754. 
     
755.         /* figure out the smallest change window */
     2 i6 f1 M. s& g/ C3 ]  f: D. F$ ?
756.         window_top = frame_y;
     
757.         window_bottom = window_height;
     
758.         window_left = 0;
     
759.         window_right = window_width;
     ( r  k5 |4 a& q+ S3 L1 F5 q9 `, a
760.         window_size = (window_right - window_left) * (window_bottom - window_top);
     8 @: a0 d+ K7 j, P3 }! d0 h. Q
761. 
     ) q9 n% V8 L# e& _2 y
762.         /* compress the frame */
     6 s  H+ a7 {% Y" F9 }5 G- W
763.         reset_put_bits(pb);
     1 ?5 J2 L4 |9 P
764.         compress_window(pb, full_window, window_width, window_top,
     
765.             window_bottom, window_left, window_right);
     
766. 
     ! n# a& M! L6 J+ Y. p3 U5 }6 Y
767.         if (rbt->dump_frames)
     2 Z. w) R, B# A( ^
768.         {
     
769.             /* dump the frame plotted onto the full window prior to encoding,
     3 W0 \5 O" u" Y6 b6 Q. `. [
770.              * with subtitle */
     3 B# W3 i) o! y, [* o
771.             sprintf(filename, "pre-encoding-frame-%03d.pnm", i);
     
772.             dump_pnm_file(filename, rbt, full_window, window_width, window_height);
     
773.         }
     
774. 
     $ B* |- V1 a4 ]2 z
775.         free(decoded_frame);
     1 U% _: B6 k9 K' n7 _8 s+ e# x) q% B
776. 
     2 F! o6 \5 q% I5 A0 L! p, P5 Y: F
777.         /* update the frame header */
     
778.         /* width */
     
779.         rbt->frame_load_buffer[4] = (window_right - window_left) & 0xFF;
     ' \9 A, ^  G0 g. d0 D4 k
780.         rbt->frame_load_buffer[5] = (window_right - window_left) >> 8;
     
781.         /* height */
     
782.         rbt->frame_load_buffer[6] = (window_bottom - window_top) & 0xFF;
     
783.         rbt->frame_load_buffer[7] = (window_bottom - window_top) >> 8;
     % c  Z  P0 A4 M! D7 O
784.         /* origin X */
     
785.         rbt->frame_load_buffer[12] = window_left & 0xFF;
     ( f' Q8 P/ f7 n+ z
786.         rbt->frame_load_buffer[13] = window_left >> 8;
     % C, g! q' L% h5 A. L
787.         /* origin Y */
     + ^; f3 N2 _# w  _3 T7 R2 |( R
788.         rbt->frame_load_buffer[14] = window_top & 0xFF;
     3 x+ g  w/ S- `0 \. m
789.         rbt->frame_load_buffer[15] = window_top >> 8;
     
790.         /* fragment payload size */
     
791.         rbt->frame_load_buffer[16] = (pb->byte_index + 10) & 0xFF;
     
792.         rbt->frame_load_buffer[17] = (pb->byte_index + 10) >> 8;
     ( T9 b% Q' j- ?* f3 k
793.         /* fragment count (1) */
     9 e( g6 H; C( P/ [; W- G" W  F
794.         rbt->frame_load_buffer[18] = 1;
     
795.         rbt->frame_load_buffer[19] = 0;
     
796. 
     2 U# \! m5 p* w9 n( Z  \
797.         /* update the fragment header */
     
798.         /* compressed size */
     
799.         rbt->frame_load_buffer[24 + 0] = (pb->byte_index >>  0) & 0xFF;
     # n5 J3 z; L2 M
800.         rbt->frame_load_buffer[24 + 1] = (pb->byte_index >>  8) & 0xFF;
     
801.         rbt->frame_load_buffer[24 + 2] = (pb->byte_index >> 16) & 0xFF;
     
802.         rbt->frame_load_buffer[24 + 3] = (pb->byte_index >> 24) & 0xFF;
     & L. B' z. U' M9 ]6 r
803.         /* decompressed size */
     
804.         rbt->frame_load_buffer[24 + 4] = (window_size >>  0) & 0xFF;
     
805.         rbt->frame_load_buffer[24 + 5] = (window_size >>  8) & 0xFF;
     
806.         rbt->frame_load_buffer[24 + 6] = (window_size >> 16) & 0xFF;
     
807.         rbt->frame_load_buffer[24 + 7] = (window_size >> 24) & 0xFF;
     
808.         /* compression format 0 */
     $ `9 G  b3 S/ C1 A" o8 D
809.         rbt->frame_load_buffer[24 + 8] = 0;
     
810.         rbt->frame_load_buffer[24 + 9] = 0;
     
811. 
     
812.         /* write the 24-byte frame header and the 10-byte fragment header */
     
813.         if (fwrite(rbt->frame_load_buffer, 24 + 10, 1, outrbt_file) != 1)
     1 |" X3 l. x$ r" @9 v5 G2 V6 w( H
814.         {
     
815.             printf("problem writing frame %d\n", i);
     9 h, G5 ^3 k% n3 O8 Y' B
816.             return 0;
     
817.         }
     
818. 
     
819.         /* write the new compressed frame data */
     
820.         if (fwrite(pb->bytes, pb->byte_index, 1, outrbt_file) != 1)
     - D8 z5 Y6 |# p; O$ P
821.         {
     
822.             printf("problem writing frame %d\n", i);
     / R+ Y6 D5 ~2 U, }; V
823.             return 0;
     
824.         }
     
825. 
     7 N# F: ^# F6 p6 t/ @1 t
826.         /* write the audio data */
     * r; u3 F* e& T! \- I* s! z
827.         if (fwrite(&rbt->frame_load_buffer[video_frame_size], frame_size - video_frame_size, 1, outrbt_file) != 1)
     7 r6 b5 J: V1 u' J4 T7 a6 Z2 Q
828.         {
     : j* y( j- e0 q' C0 y" I2 K/ ~# d
829.             printf("problem writing frame %d\n", i);
     
830.             return 0;
     
831.         }
     
832. 
     6 ^! Z9 I1 Z; ^  u# @9 C
833.         /* update the table entries */
       N7 o3 P) H2 d5 q4 v, |/ U9 W
834.         video_frame_size = pb->byte_index + 24 + 10;
     7 V, H8 [! f5 x# B. [
835.         frame_size = video_frame_size + audio_frame_size;
     $ S! _' W1 ~2 w$ I% C& X9 {4 }
836.         rbt->frame_size_table[i*2+0] = frame_size & 0xFF;
     
837.         rbt->frame_size_table[i*2+1] = frame_size >> 8;
     
838.         rbt->video_frame_size_table[i*2+0] = video_frame_size & 0xFF;
     * ^6 |$ c! j4 t/ H
839.         rbt->video_frame_size_table[i*2+1] = video_frame_size >> 8;
     
840.     }
     5 w- U3 J( O& n; y1 @# m
841. 
     
842.     printf("maximum dimensions seen are %dx%d\n", max_width, max_height);
     
843. 
     ; u) V. U2 s7 A  ?' B
844.     delete_put_bits(pb);
     
845.     free(full_window);
     
846. 
     
847.     return 1;
     ' M3 q& `/ m: f5 x* I5 R3 c. x
848. }
     
849. 
     
850. int main(int argc, char *argv[])
     
851. {
     
852.     char *subtitle_filename;
     
853.     FILE *subtitle_file;
     2 w6 v6 N7 K3 `4 z
854.     char *inrbt_filename;
     
855.     FILE *inrbt_file;
     ) k1 s: Y- t1 F' ^" M+ i
856.     char *outrbt_filename;
     
857.     FILE *outrbt_file;
     0 r; Z$ M" M/ ~7 X0 G- S( w
858.     rbt_dec_context rbt;
     & [' F; d  A4 [
859.     int origin_x;
     
860.     int origin_y;
     $ _1 ?8 O8 Z) g' y$ Y& V9 N2 W- t
861.     int window_width;
     % z" c9 {% j/ k' g( e- A8 t8 n
862.     int window_height;
     . W: s: g+ a9 O4 d1 E" m: c% l
863. 
     
864.     /* testing the bit functions */
     
865. #if 0
     
866.     int i;
     ; k: G$ \; g6 r. N
867.     uint8_t bytestream[] = { 0x55, 0xAA, 0x00, 0xAA, 0x55, 0x77, 0xFF, 0x1B, 0x70, 0x8F };
     
868.     int bytestream_size = 10;
     
869.     get_bits_context gb;
     
870.     put_bits_context *pb;
     ; s3 r! B- r7 s0 V/ R
871.     int bits;
     # L: I* Z$ Z$ N3 W( ?
872. 
     ' b4 v7 s& `8 p+ e8 d
873.     init_get_bits(&gb, bytestream, bytestream_size);
     
874.     pb = init_put_bits();
     5 h- V$ A  H% J5 R$ v9 O6 T. i
875. 
     9 D& D# K' v! s: @$ L' ]* ^2 G
876.     for (i = 1; i <= 12; i++)
     2 ~( `/ l. P7 k- M# M2 z5 \* x
877.     {
     7 M0 K' J/ B: ?/ \1 o
878.         bits = view_bits(&gb, i);
     5 j* T8 m- I; P9 u+ ?3 @5 S2 o
879.         printf("view %d bits: %d\n", i, bits);
     - {. S: J4 m/ l; u/ h) V2 L
880.         printf("read %d bits: %d\n", i, read_bits(&gb, i));
     : r; N' z  d# Y/ |$ G
881.         put_bits(pb, bits, i);
     
882.     }
     
883.     put_bits_flush(pb);
     
884. 
     
885.     printf("original bytestream:\n");
     
886.     for (i = 0; i < bytestream_size; i++)
     
887.         printf(" %02X", bytestream[i]);
       i- ?8 o5 B8 c/ d: G0 n6 D' S
888.     printf("\nnewbytestream:\n");
     
889.     for (i = 0; i < pb->byte_index; i++)
     
890.         printf(" %02X", pb->bytes[i]);
     
891.     printf("\n");
     
892. 
     
893.     delete_get_bits(&gb);
     
894.     free(pb);
     1 a9 p* J5 G+ g5 O6 a' B
895. #endif
     , O! `% Z, O( v! J+ f4 u2 E) \6 G
896. 
     & ^4 Q4 J+ H0 a3 m: ?- H
897.     /* validate the number of arguments */
     
898.     if (argc != 8 && argc != 9)
     
899.     {
     $ O" R; _9 _8 b' C
900.         printf("USAGE: subtitle-rbt <subtitles.ass> <in.rbt> <out.rbt> <origin X> <origin Y> <width> <height> [dump_frames]\n");
     
901.         return 1;
     
902.     }
     
903.     subtitle_filename = argv[1];
     " |/ S9 V! U; P2 _4 _$ J
904.     inrbt_filename = argv[2];
     
905.     outrbt_filename = argv[3];
     
906.     origin_x = atoi(argv[4]);
     % Y$ r& A: v9 @( A# S) F4 Z0 }
907.     origin_y = atoi(argv[5]);
     
908.     window_width = atoi(argv[6]);
     & Y3 a. ~9 r( L8 v# Z
909.     window_height = atoi(argv[7]);
     : N- `# U5 u/ D/ K- c
910.     rbt.dump_frames = 0;
     $ U( f% c: s1 n- c
911.     if (argc == 9)
     
912.         rbt.dump_frames = 1;
     5 _+ K6 V% j) s% B  P/ }  R
913. 
     
914.     /* verify that the specified input files are valid */
     : a: B. P& g" }: D* ^0 U
915.     subtitle_file = fopen(subtitle_filename, "r");
     
916.     if (!subtitle_file)
     
917.     {
     9 ~+ h9 v+ p( n5 }4 O6 u. ]
918.         perror(subtitle_filename);
     0 p# h8 _, o/ }  b
919.         return 1;
     . K- |5 @. l0 V8 e, {. }! x6 T
920.     }
     / n  D" F8 X2 s/ d6 D6 {3 O
921.     fclose(subtitle_file);
     / }# h7 w; z' b# l
922.     inrbt_file = fopen(inrbt_filename, "rb");
     
923.     if (!inrbt_file)
     6 @, C# P& Q! V( J' Z
924.     {
     
925.         perror(inrbt_filename);
     ! B7 Q  g1 X' E# i9 _; b
926.         return 1;
     " I& l4 K2 U3 V$ `. l1 B  m
927.     }
     / ~3 f( f5 I8 i6 k
928. 
     
929.     /* initialize the subtitle support */
     
930.     rbt.ass_lib = ass_library_init();
     
931.     rbt.ass_renderer = ass_renderer_init(rbt.ass_lib);
     
932.     rbt.ass_track = ass_read_file(rbt.ass_lib, subtitle_filename, "UTF-8");
     8 F7 j" f% v) I+ v# _
933.     ass_set_frame_size(rbt.ass_renderer, window_width, window_height);
     
934.     ass_set_fonts(rbt.ass_renderer, NULL, NULL, 1, NULL, 1);
     
935. 
     " }2 U3 b% I" r
936.     /* open the output file */
     
937.     outrbt_file = fopen(outrbt_filename, "wb");
     
938.     if (!outrbt_file)
     " B" n$ W* h% F' M' e- A
939.     {
     6 h2 W/ b9 f4 W
940.         perror(outrbt_filename);
     % P. n' I! Y/ ~* }. h5 q+ ?
941.         return 1;
     
942.     }
     + J) V$ p" f* R" T  B4 h
943. 
     
944.     /* transfer header from input to output */
     
945.     if (!load_and_copy_rbt_header(&rbt, inrbt_file, outrbt_file))
     
946.         return 1;
     
947. 
     ( U8 k" Q- c5 ^8 p
948.     /* rewrite the frames */
     
949.     if (!copy_frames(&rbt, inrbt_file, outrbt_file, origin_x, origin_y,
     
950.         window_width, window_height))
     . B7 `0 u( w4 u
951.         return 1;
     
952. 
     
953.     /* write the modified frame size tables back to the file */
     
954.     fseek(outrbt_file, rbt.video_frame_size_table_offset, SEEK_SET);
     ( }. W9 D, q9 N% w% K* ~! W' U
955.     fwrite(rbt.video_frame_size_table, rbt.frame_count * sizeof(uint16_t), 1, outrbt_file);
     
956.     fseek(outrbt_file, rbt.frame_size_table_offset, SEEK_SET);
     
957.     fwrite(rbt.frame_size_table, rbt.frame_count * sizeof(uint16_t), 1, outrbt_file);
     3 p; f; ~! ~# y9 X
958. 
     ( Z) N3 Z. u  s
959.     /* finished with files */
     
960.     fclose(inrbt_file);
     . G0 q7 w6 g6 _* P$ t/ ^5 ^( C
961.     fclose(outrbt_file);
     6 K2 \) {0 w& s5 R
962. 
     
963.     /* clean up subtitle library */
     
964.     ass_free_track(rbt.ass_track);
     
965.     ass_renderer_done(rbt.ass_renderer);
     
966.     ass_library_done(rbt.ass_lib);
     
967. 
     
968.     /* clean up */
     1 l! C) x& i/ s+ G( K* S: O
969.     free(rbt.frame_load_buffer);
     / g$ ~/ M; \6 r; H( y$ T
970.     free(rbt.video_frame_size_table);
     6 M. {$ n1 r  t
971.     free(rbt.frame_size_table);
     
972. 
     ! u# k- J2 y0 S2 q$ I
973.     return 0;
     6 Z6 D# e: U( i" |( g- Q
974. }

复制代码

8 B9 J9 d/ I  ]2 n- S( v$ K
8 C# W. t- S1 u3 O4 }
/ @6 U4 u; k2 D

soring123

这游戏有字幕吗？

shane007

引用第1楼soring123于2009-11-19 11:09发表的  :
, [6 f  g! H$ _' P5 r8 v这游戏有字幕吗？

3 }1 @# z2 D" n  F好像没有字幕，我说的是给视频外挂字幕方式的汉化。
就像syberia2汉化版下面那行字一样。

soring123

我记得是没字幕的 比较麻烦 都是视频的

shane007

引用第3楼soring123于2009-11-19 17:07发表的  :
我记得是没字幕的 比较麻烦 都是视频的

0 k. ?1 V7 Y! p; ]给视频外挂字幕方式汉化也许能行。
. J  c5 Y  ]2 c要结合dosbox和代理dll技术。

宿矢

求汉化啊！

shane007

顶上来